/**
 *  单线图（相对位置--xy走向值）
 *  2019-8-5 10:11:01
 */



//svg矢量图对象
var svg;
var pGuid; 	                // 项目ID
var pBName;	                // 项目名称
var LineArea_1;             // 线路台区
//单线图数据
// var svgData;//之前参考点位，拉线，交叉跨越
var svgPoint;              //点位
var svgRawPoint;           //点位原始数据
var svgPointForNode;       //  节点点位的关联下联点位信息
var svgLaxian;              //拉线
var svgCross;               //跨越物
var svgSpec;                //项目线路总长，各电压线路长度，设备、杆塔多少基，所选材料型号、数量，交叉跨越几处
//矢量图宽度
var svgWidth=900;
//矢量图高度
var svgHeight=900;
//经纬度放大倍数
var zoomNum=400000;
//标志矩形框的宽度
var svgRectWidth=340;
//标志矩形框的高度
var svgRectHeight=555;
//矩形框的误差值
var wuchaData=50;
//矢量图最小的宽度和高度
var minSvgWidth=900;
var minSvgHeight=900;
//设计单位
var textsjdw="单位名称";
//工程名称
var textgcmc="工程名称";
var projectName="项目名称";
var stageName="项目阶段";

//默认颜色
var default_color="RGB(128,128,128)";
//黑色
var black_color="RGB(0,0,0)";
//白色
var white_color="RGB(255,255,255)";
/**
 * svg初始化
 */
function svg_init(){
    svg.clear();
    svgWidth=svg.attr("width");
    svgHeight=svg.attr("height");
    //标尺外宽
    // var lineType=$("#explorationType").val();
    // if(lineType == 11){
    svg_new_init();
    // }else{//拆旧
    //     svg_old_init()
    // }
}

function zhibei(svgWidth){
    //指北表标志
    svg.paper.text(svgWidth-34, 45, "N").attr({
        style:"font-size:10pt",fill:default_color
    });
    svg.paper.polygon([svgWidth-30,50,svgWidth-50,100,svgWidth-30,85]).attr(
        {
            fill:black_color,stroke:black_color
        }
    );

    svg.paper.line(svgWidth-30, 50, svgWidth-50,100).attr({
        stroke: black_color,
        strokeWidth: 1,
    });
    svg.paper.line(svgWidth-50, 100, svgWidth-30,85).attr({
        stroke: black_color,
        strokeWidth: 1,
    });
    svg.paper.line(svgWidth-30,85, svgWidth-10,100).attr({
        stroke: black_color,
        strokeWidth: 1,
    });
    svg.paper.line(svgWidth-10,100,svgWidth-30, 50).attr({
        stroke: black_color,
        strokeWidth: 1,
    });
}

/**
 *选择拆旧的时候的标尺
 */
function svg_old_init(){
    var x1= 40,x2=200,y=20,h=40,i=0;
    svg_rect(0,0,340,400,black_color);
    svg_old_transformer(x1,y+h*i,true);
    svg_old_pad_mounted(x2,y+h*i++,true);
    svg_old_poles(x1-5,y+h*i,true);
    svg_old_10kv_lines(x2-30,y+h*i,x2+30,y+h*i++,true);
    svg_old_38_lines(x1-30,y+h*i,x1+30,y+h*i,true);
    svg_old_22_lines(x2-30,y+h*i,x2+30,y+h*i++,true);

    svg_old_cable_wall(x1,y+h*i,true);
    svg_old_passageway_wall(x2,y+h*i++,true);
    //电缆
    svg_old_cable_well(x1,y+h*i,true);
    //特征点
    svg_crossing_thing(x2,y+h*i++,true,"跨越物");

    svg_catch_fire_point(x1,y+h*i,true);
    //拉线
    svg_pull_rule(x2,y+h*i++);

    svg_rect_center_text(x1,y+h*i,"户表箱","户表箱",true);
    svg_next_door(x2,y+h*i++,true,"下户名称","下户数","下户点")

    svg_rect_center_text(x1,y+h*i,"开关站","开关站",true);
    svg_rect_center_text(x2,y+h*i++,"配电室","配电室",true);

    svg_rect_center_text(x1,y+h*i,"分支箱","电缆分支箱",true);
    svg_rect_center_text(x2,y+h*i++,"环网柜","环网柜",true);


}

/**
 * 选择新建的时候标尺
 */
function svg_new_init(){
    var x1= 40,x2=200,y=20,h=40,i=0;
    svg_rect(0,0,340,635,black_color);
    //图例
    svg_tuli(0,30,340,595);i++;
    svg_old_transformer(x1,y+h*i,true);
    svg_new_transformer(x2,y+h*i++,true);
    svg_old_pad_mounted(x1,y+h*i,true);
    svg_new_pad_mounted(x2,y+h*i++,true);
    svg_old_poles(x1-5,y+h*i,true);
    svg_new_poles(x2-5,y+h*i++,true);
    svg_old_10kv_lines(x1-30,y+h*i,x1+30,y+h*i,true);
    svg_new_10kv_lines(x2-30,y+h*i,x2+30,y+h*i++,true);

    //svg_new_38_lines(200,100,100,200,true);
    svg_old_38_lines(x1-30,y+h*i,x1+30,y+h*i,true);
    svg_new_38_lines(x2-30,y+h*i,x2+30,y+h*i++,true);

    svg_old_22_lines(x1-30,y+h*i,x1+30,y+h*i,true);
    svg_new_22_lines(x2-30,y+h*i,x2+30,y+h*i++,true);

    svg_old_cable_wall(x1,y+h*i,true);
    svg_new_cable_wall(x2,y+h*i++,true);

    svg_old_passageway_wall(x1,y+h*i,true);
    svg_new_passageway_wall(x2,y+h*i++,true);
    //电缆
    svg_old_cable_well(x1,y+h*i,true);
    svg_new_cable_well(x2,y+h*i++,true);

    svg_catch_fire_point(x1,y+h*i,true);
    //拉线
    svg_pull_rule(x2,y+h*i++);

    svg_rect_center_text(x1,y+h*i,"户表箱","户表箱",true);
    svg_next_door(x2,y+h*i++,true,"下户名称","下户数","下户点")

    svg_rect_center_text(x1,y+h*i,"开关柜","开关柜",true);
    svg_rect_center_text(x2,y+h*i++,"配电室","配电室",true);

    svg_rect_center_text(x1,y+h*i,"分支箱","电缆分支箱",true);
    svg_rect_center_text(x2,y+h*i++,"环网柜","环网柜",true);

    //特征点
    svg_crossing_thing(x1,y+h*i,true,"跨越物");

    //  旧杆塔
    svg_old_gt(x2,y+h*i++,true);
    //  墙支架
    svg_wall_support(x1,y+h*i,true);
}


/**
 * 画矩形
 * xy  左上角坐标
 * width height 高度和宽度
 * color 边框颜色
 */
function svg_rect(x,y,width,height,color){
    svg.paper.rect(x, y, width, height, 0).attr({
        stroke:color,fill:"none"
    });
}

/**
 * 画图例
 */
function svg_tuli(x,y,width,height){
    svg.paper.line(x, y, x+width,y).attr({
        stroke: black_color,
        strokeWidth: 1,
    });

    svg.paper.text(x+width/3, y-8, "图").attr({
        style:"font-size:10pt",fill:default_color
    });
    svg.paper.text(x+width*2/3, y-8, "例").attr({
        style:"font-size:10pt",fill:default_color
    });
}

/**
 * 画原有变压器
 */
function svg_old_transformer(x,y,isSign){
    svg.paper.circle(x-5,y, 10).attr({
        fill:default_color,stroke:black_color
    });
    svg.paper.circle(x+5,y, 10).attr({
        fill:"none",stroke:black_color
    });
    if(isSign){
        svg.paper.text(x+30, y+5, "原有变压器").attr({
            style:"font-size:10pt",fill:default_color
        });
    }
}

/**
 * 画新建变压器
 */
function svg_new_transformer(x,y,isSign){
    svg.paper.circle(x-5,y, 10).attr({
        fill:"none",stroke:black_color
    });
    svg.paper.circle(x+5,y, 10).attr({
        fill:"none",stroke:black_color
    });
    if(isSign){
        svg.paper.text(x+30, y+5, "新建变压器").attr({
            style:"font-size:10pt",fill:default_color
        });
    }
}

/**
 * 原有箱式变压器
 */
function svg_old_pad_mounted(x,y,isSign){
    svg.paper.rect(x-23, y-15, 46, 30, 0).attr({
        stroke:black_color,fill:"none"
    });
    svg.paper.circle(x-5,y, 10).attr({
        fill:default_color,stroke:black_color
    });
    svg.paper.circle(x+5,y, 10).attr({
        fill:"none",stroke:black_color
    });
    if(isSign){
        svg.paper.text(x+30, y+5, "原有箱式变").attr({
            style:"font-size:10pt",fill:default_color
        });
    }
}

/**
 * 新建箱式变压器
 */
function svg_new_pad_mounted(x,y,isSign){
    svg.paper.rect(x-23, y-15, 46, 30, 0).attr({
        stroke:black_color,fill:"none"
    });
    svg.paper.circle(x-5,y, 10).attr({
        fill:"none",stroke:black_color
    });
    svg.paper.circle(x+5,y, 10).attr({
        fill:"none",stroke:black_color
    });
    if(isSign){
        svg.paper.text(x+30, y+5, "新建箱式变").attr({
            style:"font-size:10pt",fill:default_color
        });
    }
}

/**
 * 原有杆塔
 */
function svg_old_poles(x,y,isSign){
    svg.paper.circle(x,y, 10).attr({
        fill:default_color,stroke:black_color
    });
    if(isSign){
        svg.paper.text(x+30, y+5, "原有杆塔").attr({
            style:"font-size:10pt",fill:default_color
        });
    }
}


/**
 * 新建杆塔
 */
function svg_new_poles(x,y,isSign,height){

    svg.paper.circle(x,y, 10).attr({
        fill:white_color,stroke:black_color
    });
    if(isSign){
        // alertTip("a="+x+","+y);
        svg.paper.text(x+30, y+5, "新建杆塔").attr({
            style:"font-size:10pt",fill:default_color
        });
    }else{
        // alertTip("b="+x+","+y);
        if(height!=undefined){
            if(height.length==1){
                svg.paper.text(x-4,y+5, height);
            }else{
                svg.paper.text(x-8,y+5, height);
            }
        }
    }
}


/**
 * 原有10KV线路
 */
function svg_old_10kv_lines(x1,y1,x2,y2,isSign){
    //连接2点线
    svg.paper.line(x1, y1, x2,y2).attr({
        stroke: black_color,
        strokeWidth: 3,
        strokeDasharray:"5,5",
    });
    if(isSign && y1==y2){
        svg.paper.text(x2, y2+5, "原有10KV线路").attr({
            style:"font-size:10pt",fill:default_color
        });
    }
    //横坐标相等
    if(y1==y2){
        var xx1=(x2+x1)/2;
        var hh1=10;
        svg.paper.line(xx1, y1-hh1, xx1,y1+hh1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(xx1-5, y1-hh1, xx1-5,y1+hh1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(xx1+5, y1-hh1, xx1+5,y2+hh1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
    }else if(x1==x2){//纵坐标相等
        var yy1=(y2+y1)/2;
        var hh1=10;
        svg.paper.line(x1-hh1, yy1, x1+hh1,yy1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(x1-hh1, yy1-5, x1+hh1,yy1-5).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(x1-hh1, yy1+5, x1+hh1,yy1+5).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
    }else{
        var k = (y1-y2)/(x1-x2);
        var b=y1-k*x1;
        var k2=-1/k;
        var yy2=(y1+y2)/2;
        var xx2=(x1+x2)/2;
        var b2=yy2-k2*xx2;
        var hh1=20;
        var hh2=5;
        var points = getPointBykbAndDistance(k,b,hh2,xx2,yy2);
        drawLines1(k2,b2,hh1,xx2,yy2);
        var b3=points.y1-k2*points.x1;
        drawLines1(k2,b3,hh1,points.x1,points.y1);
        var b4=points.y2-k2*points.x2;
        drawLines1(k2,b4,hh1,points.x2,points.y2);

    }

}

/**
 * 新建10KV线路
 */
function svg_new_10kv_lines(x1,y1,x2,y2,isSign){
    //连接2点线
    svg.paper.line(x1, y1, x2,y2).attr({
        stroke: black_color,
        strokeWidth: 3,
    });
    if(isSign && y1==y2){
        svg.paper.text(x2, y2+5, "新建10KV线路").attr({
            style:"font-size:10pt",fill:default_color
        });
    }
    //横坐标相等
    if(y1==y2){
        var xx1=(x2+x1)/2;
        var hh1=10;
        svg.paper.line(xx1, y1-hh1, xx1,y1+hh1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(xx1-5, y1-hh1, xx1-5,y1+hh1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(xx1+5, y1-hh1, xx1+5,y2+hh1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
    }else if(x1==x2){//纵坐标相等
        var yy1=(y2+y1)/2;
        var hh1=10;
        svg.paper.line(x1-hh1, yy1, x1+hh1,yy1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(x1-hh1, yy1-5, x1+hh1,yy1-5).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(x1-hh1, yy1+5, x1+hh1,yy1+5).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
    }else{
        var k = (y1-y2)/(x1-x2);
        var b=y1-k*x1;
        var k2=-1/k;
        var yy2=(y1+y2)/2;
        var xx2=(x1+x2)/2;
        var b2=yy2-k2*xx2;
        var hh1=20;
        var hh2=5;
        var points = getPointBykbAndDistance(k,b,hh2,xx2,yy2);
        drawLines1(k2,b2,hh1,xx2,yy2);
        var b3=points.y1-k2*points.x1;
        drawLines1(k2,b3,hh1,points.x1,points.y1);
        var b4=points.y2-k2*points.x2;
        drawLines1(k2,b4,hh1,points.x2,points.y2);

    }

}


/**
 * 原有0.38KV线路
 */
function svg_old_38_lines(x1,y1,x2,y2,isSign){
    //连接2点线
    svg.paper.line(x1, y1, x2,y2).attr({
        stroke: black_color,
        strokeWidth: 2,
        strokeDasharray:"5,5",
    });
    if(isSign && y1==y2){
        svg.paper.text(x2, y2+5, "原有0.38KV线路").attr({
            style:"font-size:10pt",fill:default_color
        });
    }
    //横坐标相等
    if(y1==y2){
        var xx1=(x2+x1)/2;
        var hh1=10;
        svg.paper.line(xx1, y1-hh1, xx1,y1+hh1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(xx1-5, y1-hh1, xx1-5,y1+hh1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(xx1+5, y1-hh1, xx1+5,y2+hh1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(xx1+10, y1-hh1, xx1+10,y2+hh1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
    }else if(x1==x2){//纵坐标相等
        var yy1=(y2+y1)/2;
        var hh1=10;
        svg.paper.line(x1-hh1, yy1, x1+hh1,yy1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(x1-hh1, yy1-5, x1+hh1,yy1-5).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(x1-hh1, yy1+5, x1+hh1,yy1+5).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(x1-hh1, yy1+10, x1+hh1,yy1+10).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
    }else{
        var k = (y1-y2)/(x1-x2);
        var b=y1-k*x1;
        var k2=-1/k;
        var yy2=(y1+y2)/2;
        var xx2=(x1+x2)/2;
        var b2=yy2-k2*xx2;
        var hh1=20;
        var hh2=5;
        var points = getPointBykbAndDistance(k,b,hh2,xx2,yy2);
        //drawLines1(k2,b2,hh1,xx2,yy2);
        var b3=points.y1-k2*points.x1;
        drawLines1(k2,b3,hh1,points.x1,points.y1);
        var b4=points.y2-k2*points.x2;
        drawLines1(k2,b4,hh1,points.x2,points.y2);

        var points2 = getPointBykbAndDistance(k,b,hh2,points.x1,points.y1);

        var b5=points2.y1-k2*points2.x1;
        drawLines1(k2,b5,hh1,points2.x1,points2.y1);
        var b6=points2.y2-k2*points2.x2;
        drawLines1(k2,b6,hh1,points2.x2,points2.y2);

    }

}


/**
 * 新建0.38KV线路
 */
function svg_new_38_lines(x1,y1,x2,y2,isSign){
    //连接2点线
    svg.paper.line(x1, y1, x2,y2).attr({
        stroke: black_color,
        strokeWidth: 2,
    });
    if(isSign && y1==y2){
        svg.paper.text(x2, y2+5, "新建0.38KV线路").attr({
            style:"font-size:10pt",fill:default_color
        });
    }
    //横坐标相等
    if(y1==y2){
        var xx1=(x2+x1)/2;
        var hh1=10;
        svg.paper.line(xx1, y1-hh1, xx1,y1+hh1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(xx1-5, y1-hh1, xx1-5,y1+hh1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(xx1+5, y1-hh1, xx1+5,y2+hh1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(xx1+10, y1-hh1, xx1+10,y2+hh1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
    }else if(x1==x2){//纵坐标相等
        var yy1=(y2+y1)/2;
        var hh1=10;
        svg.paper.line(x1-hh1, yy1, x1+hh1,yy1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(x1-hh1, yy1-5, x1+hh1,yy1-5).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(x1-hh1, yy1+5, x1+hh1,yy1+5).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(x1-hh1, yy1+10, x1+hh1,yy1+10).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
    }else{
        var k = (y1-y2)/(x1-x2);
        var b=y1-k*x1;
        var k2=-1/k;
        var yy2=(y1+y2)/2;
        var xx2=(x1+x2)/2;
        var b2=yy2-k2*xx2;
        var hh1=20;
        var hh2=5;
        var points = getPointBykbAndDistance(k,b,hh2,xx2,yy2);
        //drawLines1(k2,b2,hh1,xx2,yy2);
        var b3=points.y1-k2*points.x1;
        drawLines1(k2,b3,hh1,points.x1,points.y1);
        var b4=points.y2-k2*points.x2;
        drawLines1(k2,b4,hh1,points.x2,points.y2);

        var points2 = getPointBykbAndDistance(k,b,hh2,points.x1,points.y1);

        var b5=points2.y1-k2*points2.x1;
        drawLines1(k2,b5,hh1,points2.x1,points2.y1);
        var b6=points2.y2-k2*points2.x2;
        drawLines1(k2,b6,hh1,points2.x2,points2.y2);

    }

}

/**
 * 原有0.22KV线路
 */
function svg_old_22_lines(x1,y1,x2,y2,isSign){
    //连接2点线
    svg.paper.line(x1, y1, x2,y2).attr({
        stroke: black_color,
        strokeWidth: 1,
        strokeDasharray:"5,5",
    });
    if(isSign && y1==y2){
        svg.paper.text(x2, y2+5, "原有0.22KV线路").attr({
            style:"font-size:10pt",fill:default_color
        });
    }
    //横坐标相等
    if(y1==y2){
        var xx1=(x2+x1)/2;
        var hh1=10;
        svg.paper.line(xx1, y1-hh1, xx1,y1+hh1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(xx1-5, y1-hh1, xx1-5,y1+hh1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
    }else if(x1==x2){//纵坐标相等
        var yy1=(y2+y1)/2;
        var hh1=10;
        svg.paper.line(x1-hh1, yy1, x1+hh1,yy1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(x1-hh1, yy1-5, x1+hh1,yy1-5).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
    }else{
        var k = (y1-y2)/(x1-x2);
        var b=y1-k*x1;
        var k2=-1/k;
        var yy2=(y1+y2)/2;
        var xx2=(x1+x2)/2;
        var b2=yy2-k2*xx2;
        var hh1=20;
        var hh2=5;
        var points = getPointBykbAndDistance(k,b,hh2,xx2,yy2);
        drawLines1(k2,b2,hh1,xx2,yy2);
        var b3=points.y1-k2*points.x1;
        drawLines1(k2,b3,hh1,points.x1,points.y1);

    }

}


/**
 * 新建0.22KV线路
 */
function svg_new_22_lines(x1,y1,x2,y2,isSign){
    //连接2点线
    svg.paper.line(x1, y1, x2,y2).attr({
        stroke: black_color,
        strokeWidth: 1,
    });
    if(isSign && y1==y2){
        svg.paper.text(x2, y2+5, "新建0.22KV线路").attr({
            style:"font-size:10pt",fill:default_color
        });
    }
    //横坐标相等
    if(y1==y2){
        var xx1=(x2+x1)/2;
        var hh1=10;
        svg.paper.line(xx1, y1-hh1, xx1,y1+hh1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(xx1-5, y1-hh1, xx1-5,y1+hh1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
    }else if(x1==x2){//纵坐标相等
        var yy1=(y2+y1)/2;
        var hh1=10;
        svg.paper.line(x1-hh1, yy1, x1+hh1,yy1).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
        svg.paper.line(x1-hh1, yy1-5, x1+hh1,yy1-5).attr({
            stroke: black_color,
            strokeWidth: 1,
        });
    }else{
        var k = (y1-y2)/(x1-x2);
        var b=y1-k*x1;
        var k2=-1/k;
        var yy2=(y1+y2)/2;
        var xx2=(x1+x2)/2;
        var b2=yy2-k2*xx2;
        var hh1=20;
        var hh2=5;
        var points = getPointBykbAndDistance(k,b,hh2,xx2,yy2);
        drawLines1(k2,b2,hh1,xx2,yy2);
        var b3=points.y1-k2*points.x1;
        drawLines1(k2,b3,hh1,points.x1,points.y1);

    }

}
/**
 * 已知k b 线段距离h 线段中心点坐标 画线段
 * (x1-x2)²+(y1-y2)²=h²
 * x1+x2=2*x0
 * y2=k*x2+b
 * y1=k*x1+b
 */
function drawLines1(k,b,h,x0,y0){
    x1=Math.sqrt(h*h/(4+4*k*k))+x0;
    y1=k*x1+b;
    x2=2*x0-x1;
    y2=k*x2+b;
    svg.paper.line(x1, y1, x2, y2).attr({
        stroke: black_color,
        strokeWidth: 1,
    });
}
/**
 *计算在一条直线上从某点开始到一定距离的下一个点
 * (x1-x0)²+(y1-y0)²=h²
 *  y1=k*x1+b
 */
function getPointBykbAndDistance(k,b,h,x0,y0){
    var a=1+k*k;
    var bb=2*k*(b-y0)-2*x0;
    var c=x0*x0+(b-y0)*(b-y0)-h*h;
    var x1=(-1*bb+Math.sqrt(bb*bb-4*a*c))/(2*a);
    var x2=(-1*bb-Math.sqrt(bb*bb-4*a*c))/(2*a);
    var y1=k*x1+b;
    var y2=k*x2+b;
    return {
        x1:x1,
        y1:y1,
        x2:x2,
        y2:y2
    }
}

/**
 * 原有沿墙电缆
 */
function svg_old_cable_wall(x,y,isSign){
    svg.paper.rect(x-30, y-5, 10, 10, 0).attr({
        stroke:black_color,fill:default_color
    });

    svg.paper.rect(x+20, y-5, 10, 10, 0).attr({
        stroke:black_color,fill:default_color
    });

    svg.paper.line(x-30,  y-5, x+20, y-5).attr({
        stroke:black_color,fill:default_color
    });

    if(isSign){
        svg.paper.text(x+30, y+5, "原有电缆(沿墙)").attr({
            style:"font-size:10pt",fill:default_color
        });
    }
}

/**
 * 新建沿墙电缆
 */
function svg_new_cable_wall(x,y,isSign){
    svg.paper.rect(x-30, y-5, 10, 10, 0).attr({
        stroke:black_color,fill:"none"
    });

    svg.paper.rect(x+20, y-5, 10, 10, 0).attr({
        stroke:black_color,fill:"none"
    });

    svg.paper.line(x-30,  y-5, x+20, y-5).attr({
        stroke:black_color,fill:default_color
    });

    if(isSign){
        svg.paper.text(x+30, y+5, "新建电缆(沿墙)").attr({
            style:"font-size:10pt",fill:default_color
        });
    }
}

/**
 * 原有通道电缆
 */
function svg_old_passageway_wall(x,y,isSign){
    svg.paper.rect(x-30, y-5, 10, 10, 0).attr({
        stroke:black_color,fill:default_color
    });

    svg.paper.rect(x+20, y-5, 10, 10, 0).attr({
        stroke:black_color,fill:default_color
    });

    svg.paper.line(x-30,  y-5, x+20, y-5).attr({
        stroke:black_color,fill:default_color
    });

    svg.paper.line(x-30,  y+5, x+20, y+5).attr({
        stroke:black_color,fill:default_color
    });

    if(isSign){
        svg.paper.text(x+30, y+5, "原有电缆(通道)").attr({
            style:"font-size:10pt",fill:default_color
        });
    }
}

/**
 * 新建通道电缆
 */
function svg_new_passageway_wall(x,y,isSign){
    svg.paper.rect(x-30, y-5, 10, 10, 0).attr({
        stroke:black_color,fill:"none"
    });

    svg.paper.rect(x+20, y-5, 10, 10, 0).attr({
        stroke:black_color,fill:"none"
    });

    svg.paper.line(x-30,  y-5, x+20, y-5).attr({
        stroke:black_color,fill:default_color
    });

    svg.paper.line(x-30,  y+5, x+20, y+5).attr({
        stroke:black_color,fill:default_color
    });

    if(isSign){
        svg.paper.text(x+30, y+5, "新建电缆(通道)").attr({
            style:"font-size:10pt",fill:default_color
        });
    }
}

/**
 * 原有电缆井
 * @param x
 * @param y
 * @param isSign
 */
function svg_old_cable_well(x,y,isSign){
    var r=10;
    svg.paper.circle(x,y, r).attr({
        fill:default_color,stroke:black_color
    });

    svg.paper.line(x-r,  y, x+r, y).attr({
        stroke:black_color,fill:default_color
    });

    svg.paper.line(x,  y-r, x, y+r).attr({
        stroke:black_color,fill:default_color
    });

    if(isSign){
        svg.paper.text(x+30, y+5, "原有电缆井").attr({
            style:"font-size:10pt",fill:default_color
        });
    }
}

/**
 * 新建电缆井
 * @param x
 * @param y
 * @param isSign
 */
function svg_new_cable_well(x,y,isSign){
    var r=10;
    svg.paper.circle(x,y, r).attr({
        fill:"none",stroke:black_color
    });

    svg.paper.line(x-r,  y, x+r, y).attr({
        stroke:black_color,fill:default_color
    });

    svg.paper.line(x,  y-r, x, y+r).attr({
        stroke:black_color,fill:default_color
    });

    if(isSign){
        svg.paper.text(x+30, y+5, "新建电缆井").attr({
            style:"font-size:10pt",fill:default_color
        });
    }
}
/**
 * 搭火点
 */
function svg_catch_fire_point(x,y,isSign){
    var r=15;
    svg.paper.circle(x,y, r/2).attr({
        fill:default_color,stroke:black_color
    });
    svg.paper.circle(x,y, r).attr({
        fill:"none",stroke:black_color
    });

    if(isSign){
        svg.paper.text(x+30, y+5, "搭火点").attr({
            style:"font-size:10pt",fill:default_color
        });
    }
}

/**
 * 拉线标尺
 */
function svg_pull_rule(x,y){
    var h=30;
    svg.paper.line(x,  y-h/2, x, y+h/2).attr({
        stroke:black_color,fill:default_color
    });
    svg.paper.line(x-h/2, y+h/2, x+h/2, y+h/2).attr({
        stroke:black_color,fill:default_color
    });
    svg.paper.text(x+30, y+5, "拉线").attr({
        style:"font-size:10pt",fill:default_color
    });
}

/**
 * 矩形框中文字 户表箱 开关柜 配电室 电缆分支箱 环网柜
 */
function svg_rect_center_text(x,y,textName,textName2,isSign){
    svg.paper.rect(x-23, y-15, 38, 25, 0).attr({
        stroke:black_color,fill:white_color
    });
    svg.paper.text(x-20, y+5, textName).attr({
        style:"font-size:5pt",fill:default_color
    });
    if(isSign){
        svg.paper.text(x+30, y+5, textName2).attr({
            style:"font-size:10pt",fill:default_color
        });
    }
}

/**
 * 下户点
 * @param x
 * @param y
 * @param isSign
 * @param doorName 下户名称
 * @param doorNum 下户数
 */
function svg_next_door(x,y,isSign,doorName,doorNum,doorName2){
    var h=28;
    if(doorName != undefined && doorName!=null){
        h=doorName.length*14;
    }
    var h2=(doorNum+"").length*14;
    svg.paper.rect(x-38, y-15, h, 25, 0).attr({//宽度减5，圆角矩形，左上角坐标(x, y), 宽w,高h, 圆角大小r
        stroke:black_color,fill:white_color
    });
    svg.paper.rect(x+h-38, y-15, h2+4 , 25, 0).attr({
        stroke:black_color,fill:white_color
    });
    svg.paper.text(x-28, y+5, doorName).attr({
        style:"font-size:5pt",fill:default_color
    });
    var str = doorNum+"";
    svg.paper.text(x+h-22, y+5, str).attr({
        style:"font-size:5pt",fill:default_color
    });
    if(isSign){
        svg.paper.text(x+30+h+4 , y+5, doorName2).attr({
            style:"font-size:10pt",fill:default_color
        });
    }
}

/**
 * 特征点
 * @param x
 * @param y
 * @param isSign
 * @param thingName
 */
function svg_crossing_thing(x,y,isSign,thingName){
    if(isSign){//标尺
        var line1=svg.paper.line(x-30, y, x+10, y).attr({
            stroke:black_color,
            fill:default_color,
            //markerEnd:m2
        });
        var line2=svg.paper.line(x+72, y, x+32, y).attr({
            stroke:black_color,
            fill:default_color,
            //markerEnd:m2
        });
        svg.paper.polygon([x-10,y-5,x-10,y,x+10,y]).attr(
            {
                fill:black_color
            }
        );
        svg.paper.polygon([x+52,y-5,x+52,y,x+32,y]).attr(
            {
                fill:black_color
            }
        );
        svg.paper.text(x+84 , y+5, thingName).attr({
            style:"font-size:10pt",fill:default_color
        });
    }
}





//  旧电杆
function svg_old_gt(x,y,isSign,height){
    svg.paper.circle(x,y, 15).attr({
        fill:default_color,stroke:black_color
    });
    svg.paper.rect(x-10.61, y-10.61, 21.22, 21.22, 0).attr({
        stroke:black_color,fill:white_color
    });
    if(isSign){
        svg.paper.text(x+30, y+5, "旧电杆").attr({
            style:"font-size:10pt",fill:default_color
        });
    }else{
        if(height!=undefined){
            if(height.length==1){
                svg.paper.text(x-4,y+4, height);
            }else{
                svg.paper.text(x-8,y+4, height);
            }
        }

    }

}


//  墙支架
function svg_wall_support(x,y,isSign) {
    svg.paper.circle(x,y, 12).attr({
        fill:white_color,stroke:black_color
    });
    svg.paper.line(x-6,  y-4, x+9, y-4).attr({
        stroke:black_color,fill:default_color
    });
    svg.paper.line(x-6,  y-4, x-6, y+5).attr({
        stroke:black_color,fill:default_color
    });
    svg.paper.line(x-6,  y+2, x+7, y-4).attr({
        stroke:black_color,fill:default_color
    });
    if(isSign){
        svg.paper.text(x+30, y+5, "墙支架").attr({
            style:"font-size:10pt",fill:default_color
        });
    }/*else{
        if(height!=undefined){
            if(height.length==1){
                svg.paper.text(x-4,y+4, height);
            }else{
                svg.paper.text(x-8,y+4, height);
            }
        }

    }*/

}





//保留n位小数
function roundFun(value, n) {
    return Math.round(value*Math.pow(10,n))/Math.pow(10,n);
}

function equals(str1, str2)
{
    if(str1 == str2)
    {
        return true;
    }
    return false;
}

function isometricLineSegment(pt_id) {
    //分四个等比阶段进行表示线路
    var a = 0;
    if(eval(0)<pt_id && pt_id<=eval(20)){
        return a = 12;
    }else if(eval(20)<pt_id && pt_id<=eval(50)){
        return a = 14;
    }else if(eval(50)<pt_id && pt_id<=eval(100)){
        return a = 16;
    }else if(eval(100)<pt_id && pt_id<=eval(150)){
        return a = 18;
    }else if(eval(150)<pt_id){
        return a = 20;
    }

}

/**
 * 加载单线图数据 【放大或缩小都是重新加载单线图的生成】
 */

//  大荔横平竖直版【此版经典】

function load_svg_data(){


    var minLngNum=minLng(svgPoint);     //  最小经度
    var maxLatNum=maxLat(svgPoint);     // 最大纬度

    var maxSvgWidth=0;                  //  矩形框最大宽度
    var maxSvgHeight=0;                 //  矩形框最大高度

    /*
     *  todo 以四象限作为判定点位在xy轴方向上的位置，确认夹角大小来作为点位在xy轴上
     *  ① 四象限位置：
     *          一象限【++】，二象限【-+】，三象限【--】，四象限【+-】
     *  ② 直线与xy轴的夹角：
     *          x轴的直线方程：y=0，斜率k=0
     *          y轴的直线方程：x=0，斜率不存在
     *  ③ 点斜式的直线方程：
     *          y = kx + b
     *
     *          A(x1,y1) , B(x2,y2)
     *          k = (y2-y1)/(x2-x1)
     *  ④ 两直线的夹角公式：
     *          tanψ = (k2-k1)/(1+k1*k2)
     *          k = tanψ
     *          tan45°= 1
     *  ⑤ 最终挂靠位置：
     *          一象限：    0°<=ψ< 90°
     *                  第一种情况：0°<=ψ<= 45°，则  0 <= tanψ <= 1         依附在x轴
     *                  第二种情况：45°<ψ< 90°，则  1 < tanψ < 57.29        依附在y轴
     *
     *          二象限：    90°<ψ<= 180°
     *                  第一种情况：90°<ψ< 135°，则 -57.29 < tanψ < -1    依附在y轴
     *                  第二种情况：135°<=ψ<= 180°，则  -1 < tanψ <= 0       依附在x轴
     *
     *          三象限：    180°<ψ< 270°
     *                  第一种情况：180°<ψ<= 225°，则 0 < tanψ <= 1         依附在x轴
     *                  第二种情况：225°<ψ< 270°，则  1 < tanψ < 57.29     依附在y轴
     *
     *          四象限：    270°<ψ< 360°(0°)
     *                  第一种情况：270°<ψ< 315°，则 -57.29 < tanψ < -1   依附在y轴
     *                  第二种情况：315°<=ψ< 360°，则  -1 <= tanψ < 0         依附在x轴
     *
     *  ⑥ 算坐标流程:
     *          A、现在的点位间的平面坐标需要点位上的经纬度参与进行计算
     *          B、点位间距离等比作100，表箱、下户点作110
     *          C、在点位的经纬度基础上进行与x轴作夹角比较，根据夹角来计算点位是依附在x轴还是y轴：
     *
     */


    var abs_x = 0 , abs_y = 0;          //  起始点坐标
    var isNode_x = 0 , isNode_y = 0;    //  节点坐标
    var nux = 0;                        //  节点数

    //  求出点位的平面坐标
    for (var i in svgPoint) {
        //  经纬度
        var lng_i = svgPoint[i].pPInputlongitude;
        var lat_i = svgPoint[i].pPInputlatitude;

        //  转换为平面坐标
        svgPoint[i].x = svgPoint[i].pm_x = (lng_i - minLngNum ) * zoomNum + svgRectWidth + wuchaData;
        svgPoint[i].y = svgPoint[i].pm_y = (maxLatNum - lat_i ) * zoomNum + wuchaData;

        //  找出起始点
        if(svgPoint[i].pPUpguid == "" || svgPoint[i].pPUpguid == null){
            abs_x = svgPoint[i].pm_x;
            abs_y = svgPoint[i].pm_y;

        }
    }

    //  求下联点位的平面坐标
    for (var i in svgPoint) {

        //  当前点位经纬度
        var lng_i = svgPoint[i].pPInputlongitude;
        var lat_i = svgPoint[i].pPInputlatitude;

        //  当前点位平面坐标
        var pm_x_i = svgPoint[i].pm_x;
        var pm_y_i = svgPoint[i].pm_y;

        for (var k in svgPoint) {           //  上联信息

            //  上联点位经纬度
            var lng_k = svgPoint[k].pPInputlongitude;
            var lat_k = svgPoint[k].pPInputlatitude;

            //  上联点位平面坐标
            var pm_x_k = svgPoint[k].pm_x;
            var pm_y_k = svgPoint[k].pm_y;

            //  下联点位
            if (svgPoint[k].guid == svgPoint[i].pPUpguid ) {

                //  用经纬度坐标计算斜率
                var k0 = (lat_i-lat_k)/(lng_i-lng_k);
                //  x轴斜率
                var kx = 0 ;
                //  y轴不存在斜率，即Infinity
                //  当斜率k0出现 -Infinity 时，表示此点位组成的直线与y轴重合，且点位在y轴的负半轴
                //  当斜率k0出现 Infinity 时，表示此点位组成的直线与y轴重合，且点位在y轴的正半轴

                //  依附在x轴，【下户点、表箱距离用110，其余用100】
                if((k0<=1&&k0>=0) || (k0<0&&k0>=-1)){

                    var dc = pm_x_i - pm_x_k;   //  上下联平面坐标的x坐标的差值
                    // var dy = abs_x - pm_x_i;    //   起始点位与当前点位的x坐标的差值
                    // var df = abs_y - pm_y_i;    //   起始点位与当前点位的y坐标的差值

                    //  下户点、表箱用110
                    if(svgPoint[i].pPName=="下户点" || svgPoint[i].pPName=="表箱"){

                        if(svgPoint[i].isNode==false){          //  当前点位不是节点
                            if(dc!=110){
                                if(svgPoint[k].upper == "y"){   //  上联点位依附在y轴

                                    if(svgPoint[k].nextNum >= 0){
                                        if(dc>0){
                                            svgPoint[i].x = isNode_x + 110;
                                            svgPoint[i].y = isNode_y + 110;
                                        }else{
                                            svgPoint[i].x = isNode_x - 110;
                                            svgPoint[i].y = isNode_y + 110;
                                        }
                                    }

                                    //  2019-9-3 10:15:51
                                    // svgPoint[i].x = isNode_x;    // x轴坐标保持不变
                                    // if(svgPoint[k].nextNum > 1){ // 上联点位是节点
                                    //     svgPoint[i].y = isNode_y-i*110*0.1;
                                    // }else{                        // 上联点位不是节点
                                    //     svgPoint[i].y = svgPoint[k].y-110;
                                    // }
                                    // svgPoint[i].upper = "y"
                                }else if(svgPoint[i].upper = "x"){  //  上联点位依附在x轴
                                    svgPoint[i].y = svgPoint[k].y;  //  y轴不变
                                    if(svgPoint[k].nextNum > 1){     //  上联是节点
                                        // svgPoint[i].x = isNode_x-i*100*0.1;
                                        if(dc>0){       //  下联点位在上联点位的右边
                                            svgPoint[i].x = svgPoint[k].x+110;
                                        }else{          //  下联点位在上联点位的左边
                                            svgPoint[i].x = svgPoint[k].x-110;
                                        }
                                    }else{                            //  上联不是节点
                                        if(dc>0){
                                            svgPoint[i].x = svgPoint[k].x+110;
                                        }else{
                                            svgPoint[i].x = svgPoint[k].x-110;
                                        }
                                        // svgPoint[i].x = svgPoint[k].x-100;
                                    }
                                    svgPoint[i].upper = "x"
                                }else{  //  其他情况
                                    svgPoint[i].x = svgPoint[0].pm_x+i*110;
                                    svgPoint[i].y = abs_y;
                                }
                            }

                        }else{              //  当前点位是节点

                            if(dc!=100){
                                if(svgPoint[i].nextNum > 1){
                                    svgPoint[i].upper = "x"
                                    nux = svgPoint[i].nextNum;  //  节点数
                                    if(dc>0){                   //   节点坐标
                                        isNode_x = svgPoint[i].x = svgPoint[k].x+110;
                                    }else{
                                        isNode_x = svgPoint[i].x = svgPoint[k].x-110;
                                    }
                                    // isNode_x = svgPoint[i].x = svgPoint[0].pm_x+i*100;
                                }
                                // svgPoint[i].x = svgPoint[i].pm_x;                  //  x轴不变
                                // isNode_y = svgPoint[i].y = abs_y;        //  2019-8-26 16:30:13
                                isNode_y = svgPoint[i].y = svgPoint[k].y;
                            }

                        }

                    }else{      //  其余点位用100
                        if(svgPoint[i].isNode==false){  //  当前点位不是节点
                            if(dc!=100){
                                if(svgPoint[k].upper == "y"){   //  上联依附在y轴
                                    if(svgPoint[k].isNode){     //  上联是节点
                                        svgPoint[i].y = svgPoint[k].y;
                                        if(svgPoint[k].nextNum > 1){
                                            if(dc>0){   //  下联点位在上联的右侧
                                                svgPoint[i].x = svgPoint[k].x+100;
                                            }else{      //  下联点位在上联的左侧
                                                svgPoint[i].x = svgPoint[k].x-100;
                                            }
                                        }/*else{
                                            if(dc>0){
                                                svgPoint[i].x = svgPoint[k].x+100;
                                            }else{
                                                svgPoint[i].x = svgPoint[k].x-100;
                                            }
                                        }*/
                                        svgPoint[i].upper = "x"
                                    }else{                          //  上联点位不是节点
                                        // svgPoint[i].x = isNode_x;       //  2019-9-2 16:58:46
                                        // if(svgPoint[k].nextNum > 1){
                                        //     svgPoint[i].y = isNode_y-i*100*0.1;
                                        // }else{
                                        //     svgPoint[i].y = svgPoint[k].y-100;  //  2019-9-2 16:58:46
                                        // }
                                        // svgPoint[i].upper = "y";        //  2019-9-2 16:58:46

                                        if(dc>0){   //  下联点位在上联的右侧
                                            svgPoint[i].x = svgPoint[k].x+100;
                                        }else{      //  下联点位在上联的左侧
                                            svgPoint[i].x = svgPoint[k].x-100;
                                        }
                                        svgPoint[i].y = svgPoint[k].y
                                        svgPoint[i].upper = "x";
                                    }
                                }else if(svgPoint[k].upper == "x"){ //  上联依附在x轴
                                    svgPoint[i].y = svgPoint[k].y;
                                    if(svgPoint[k].nextNum >= 0){     //  上联是节点
                                        // svgPoint[i].x = isNode_x-i*100*0.1;
                                        if(dc>0){   //  下联点位在上联的右侧
                                            svgPoint[i].x = svgPoint[k].x+100;
                                        }else{      //  下联点位在上联的右侧
                                            svgPoint[i].x = svgPoint[k].x-100;
                                        }
                                    }/*else{                           // 上联不是节点
                                        if(dc>0){
                                            svgPoint[i].x = svgPoint[k].x+100;
                                        }else{
                                            svgPoint[i].x = svgPoint[k].x-100;
                                        }
                                        // svgPoint[i].x = svgPoint[k].x-100;
                                    }*/
                                    svgPoint[i].upper = "x"
                                }else{  //  其他情况
                                    svgPoint[i].x = svgPoint[k].x + 100;
                                    svgPoint[i].y = svgPoint[k].y;
                                }
                            }
                        }else{  //  当前点位是节点
                            if(dc!=100){
                                if(svgPoint[i].nextNum > 1){        //  x轴需要再进行调试测试  2019-8-26 16:30:13
                                    svgPoint[i].upper = "x"
                                    nux = svgPoint[i].nextNum;      //  节点数
                                    if(dc>0){       //  下联点位在上联的右侧
                                        isNode_x = svgPoint[i].x = svgPoint[k].x+100;
                                    }else{          //  下联点位在上联的左侧
                                        isNode_x = svgPoint[i].x = svgPoint[k].x-100;
                                    }
                                }
                                isNode_y = svgPoint[i].y = svgPoint[k].y;
                            }
                        }

                    }

                }

                //  依附于y轴
                if((k0>1&&k0<57.29) || (k0<-1&&k0>-57.29)){

                    var dc = pm_y_i - pm_y_k;
                    // var dt = abs_x - pm_x_i;
                    var dr = abs_y - pm_y_i;


                    if(svgPoint[i].pPName=="下户点" || svgPoint[i].pPName=="表箱"){

                        if(svgPoint[i].isNode==false){  //  当前点位不是节点
                            if(dc!=110){

                                if(svgPoint[k].nextNum > 1){    //  上联点位是节点
                                    if(nux<svgPoint[k].nextNum){//  当前节点数小于上联节点数
                                        if(dc>0){   //  x轴向右发展
                                            svgPoint[i].x = svgPoint[k].x+110;
                                        }else{      //  x轴向左发展
                                            svgPoint[i].x = svgPoint[k].x-110;
                                        }
                                        svgPoint[i].y = svgPoint[k].y;
                                    }else{                      //  当前节点数大于等于上联节点数
                                        svgPoint[i].x = isNode_x;
                                        // if(dr>0){                       //  y轴向上发展
                                        //     svgPoint[i].y = isNode_y-i*110*0.1;
                                        // }else{                          //  y轴向下发展
                                        //     svgPoint[i].y = svgPoint[k].y+110;
                                        // }

                                        if(dc>0){
                                            svgPoint[i].y = svgPoint[k].y+110;
                                        }else{
                                            svgPoint[i].y = svgPoint[k].y-110;
                                        }
                                    }

                                    nux--;
                                }else{      //  上联点位不是节点
                                    /*if(isNode_x!=0){
                                        svgPoint[i].x = isNode_x;
                                        if(dr>0){
                                            svgPoint[i].y = svgPoint[k].y-100;
                                        }else{
                                            svgPoint[i].y = svgPoint[k].y+100;
                                        }
                                    }else{*/
                                        svgPoint[i].x = svgPoint[k].x;
                                        if(dr>0){
                                            svgPoint[i].y = svgPoint[k].y-110;
                                        }else{
                                            svgPoint[i].y = svgPoint[k].y+110;
                                        }
                                    // }

                                }
                                svgPoint[i].upper = "y";                         //  依附于y轴
                            }

                        }else{  //  当前点位是节点

                            if(dc!=110){
                                svgPoint[i].upper = "y"
                                if(svgPoint[i].nextNum > 1){

                                    nux = svgPoint[i].nextNum;  //  节点数

                                    isNode_x = svgPoint[k].x;   //  节点坐标
                                    isNode_y = svgPoint[k].y;

                                    svgPoint[i].x = isNode_x;
                                    svgPoint[i].y = isNode_y+110;
                                }/*else{
                                    svgPoint[i].x = isNode_x;
                                    svgPoint[i].y = svgPoint[i].pm_y+110;
                                }*/

                            }

                        }

                    }else{  //  其他点位
                        if(svgPoint[i].isNode==false){  //  当前点位不是节点
                            if(dc!=100){

                                if(svgPoint[k].nextNum > 1){   //   上联点位是节点
                                    if(nux<svgPoint[k].nextNum){    //  当前节点数小于上联点位节点数
                                        // svgPoint[i].x = svgPoint[k].x-100;
                                        if(dc>0){   //  x轴向右发展
                                            svgPoint[i].x = svgPoint[k].x+100;
                                        }else{      //  x轴向左发展
                                            svgPoint[i].x = svgPoint[k].x-100;
                                        }
                                        svgPoint[i].y = svgPoint[k].y;
                                    }else{                          //  当前节点数大于等于上联点位节点数
                                        svgPoint[i].x = isNode_x;
                                        if(dr>0){                       //  y轴向上发展
                                            svgPoint[i].y = isNode_y-i*100*0.1;
                                        }else{                          //  y轴向下发展
                                            svgPoint[i].y = svgPoint[k].y+100;
                                        }
                                    }

                                    nux--;
                                }else{  //  上联点位不是节点
                                    /*if(isNode_x!=0){
                                        // svgPoint[i].x = isNode_x;
                                        svgPoint[i].x = svgPoint[k].x
                                        if(dc>0){
                                            svgPoint[i].y = svgPoint[k].y+100;
                                        }else{
                                            svgPoint[i].y = svgPoint[k].y-100;
                                        }
                                    }else{*/
                                        svgPoint[i].x = svgPoint[k].x;
                                        if(dc>0){       //  y轴向上发展
                                            svgPoint[i].y = svgPoint[k].y+100;
                                        }else{          //  y轴向下发展
                                            svgPoint[i].y = svgPoint[k].y-100;
                                        }
                                    // }

                                }
                                svgPoint[i].upper = "y";                         //  依附于y轴
                            }
                        }else{      //      当前点位是节点
                            if(dc!=100){
                                svgPoint[i].upper = "y"
                                if(svgPoint[i].nextNum > 1){

                                    nux = svgPoint[i].nextNum;  //  当前点位节点数

                                    isNode_x = svgPoint[k].x;   //  节点坐标
                                    isNode_y = svgPoint[k].y;

                                    svgPoint[i].x = isNode_x;
                                    svgPoint[i].y = isNode_y+100;
                                }/*else{
                                    svgPoint[i].x = isNode_x;                 //  x轴不变
                                    svgPoint[i].y = svgPoint[i].pm_y+200;
                                }*/
                            }
                        }


                    }

                }

                //  第三种情况：上联与下联组成的直线与y轴重合，不存在斜率时（即斜率∞）

                if(k0 == Infinity){   //  当前点位与上联点位组成的直线与y轴重合，且点位在y轴正半轴
                    svgPoint[i].x = svgPoint[k].x;
                    svgPoint[i].y = svgPoint[k].y-100;
                }else if(k0 == -Infinity){  //  当前点位与上联点位组成的直线与y轴重合，且点位在y轴负半轴
                    svgPoint[i].x = svgPoint[k].x;
                    svgPoint[i].y = svgPoint[k].y+100;
                }



            }

        }


        //以下用于判断DXF宽度和高度用
        if(maxSvgWidth < svgPoint[i].x+300){
            maxSvgWidth = eval(svgPoint[i].x+300);
        }
        if(maxSvgHeight < svgPoint[i].y+320){
            maxSvgHeight = eval(svgPoint[i].y+320);
        }
    }

    /**
     *  2.跨越点计算
     */
    var beforePoint , lastPoint;    //  上下联点位
    for (var i = 0; i < svgPoint.length; i++) {     //  点位
        //点位上联与交叉跨越上联点位
        for (var j = 0; j < svgCross.length; j++) { //  跨越物
            if (svgPoint[i].pPUpguid!=null && svgPoint[i].guid==svgCross[j].cCUpguid) {//上联点位
                beforePoint = svgPoint[i];
            }
            if (svgPoint[i].pPUpguid!=null && svgPoint[i].guid==svgCross[j].cCDownguid) {//下联点位
                lastPoint = svgPoint[i];
            }

            if(beforePoint != undefined && lastPoint != undefined){
                if(beforePoint.y == lastPoint.y){       //  上下联是水平排布
                    svgCross[j].x = beforePoint.x + 30;
                    svgCross[j].y = beforePoint.y;
                }else if(beforePoint.x == lastPoint.x){ //  上下联是竖直排布
                    svgCross[j].x = beforePoint.x;
                    svgCross[j].y = beforePoint.y + 30;
                }
            }
        }
    }

    // 单线框大小设置
    if(maxSvgWidth>minSvgWidth){
        svgWidth=maxSvgWidth;
    }else{
        svgWidth=minSvgWidth;
    }

    if(maxSvgHeight>minSvgHeight){
        svgHeight=maxSvgHeight;
    }else{
        svgHeight=minSvgHeight;
    }
    svg.attr({width:svgWidth,height:svgHeight});

    //指北标志
    zhibei(svgWidth);   // ok
    //描点
    drawSvgPoint();     // ok
    //画定位点之间的线
    drawSvgLine();      // ok
    //画拉线
    drawPushLine();     // ok
    //填写描述
    drawDescribetion(); // ok
    //画右下角标尺
    drawSvgRemark();    // ok
}


//  遵义横平竖直版--参考经纬度，以上联与下联组成的直线，判断与x轴y轴的夹角来依附点位

// function load_svg_data(){
//
//     var minLngNum=minLng(svgPoint);     //  最小经度
//     var maxLatNum=maxLat(svgPoint);     // 最大纬度
//
//     var maxSvgWidth=0;                  //  矩形框最大宽度
//     var maxSvgHeight=0;                 //  矩形框最大高度
//
//     /*
//      *  todo 以四象限作为判定点位在xy轴方向上的位置，确认夹角大小来作为点位在xy轴上
//      *  ① 四象限位置：
//      *          一象限【++】，二象限【-+】，三象限【--】，四象限【+-】
//      *  ② 直线与xy轴的夹角：
//      *          x轴的直线方程：y=0，斜率k=0
//      *          y轴的直线方程：x=0，斜率不存在
//      *  ③ 点斜式的直线方程：
//      *          y = kx + b
//      *
//      *          A(x1,y1) , B(x2,y2)
//      *          k = (y2-y1)/(x2-x1)
//      *  ④ 两直线的夹角公式：
//      *          tanψ = (k2-k1)/(1+k1*k2)
//      *          k = tanψ
//      *          tan45°= 1
//      *  ⑤ 最终挂靠位置：
//      *          一象限：    0°<=ψ< 90°
//      *                  第一种情况：0°<=ψ<= 45°，则  0 <= tanψ <= 1         依附在x轴
//      *                  第二种情况：45°<ψ< 90°，则  1 < tanψ < 57.29        依附在y轴
//      *
//      *          二象限：    90°<ψ<= 180°
//      *                  第一种情况：90°<ψ< 135°，则 -57.29 < tanψ < -1    依附在y轴
//      *                  第二种情况：135°<=ψ<= 180°，则  -1 < tanψ <= 0       依附在x轴
//      *
//      *          三象限：    180°<ψ< 270°
//      *                  第一种情况：180°<ψ<= 225°，则 0 < tanψ <= 1         依附在x轴
//      *                  第二种情况：225°<ψ< 270°，则  1 < tanψ < 57.29     依附在y轴
//      *
//      *          四象限：    270°<ψ< 360°(0°)
//      *                  第一种情况：270°<ψ< 315°，则 -57.29 < tanψ < -1   依附在y轴
//      *                  第二种情况：315°<=ψ< 360°，则  -1 <= tanψ < 0         依附在x轴
//      *
//      *  ⑥ 算坐标流程:
//      *          A、现在的点位间的平面坐标需要点位上的经纬度参与进行计算
//      *          B、点位间距离等比作100，表箱、下户点作110
//      *          C、在点位的经纬度基础上进行与x轴作夹角比较，根据夹角来计算点位是依附在x轴还是y轴：
//      *
//      */
//
//
//     var abs_x = 0 , abs_y = 0;          //  起始点坐标
//     var isNode_x = 0 , isNode_y = 0;    //  节点坐标
//     var nux = 0;                        //  节点数
//
//     //  求出点位的平面坐标
//     for (var i in svgPoint) {
//         //  经纬度
//         var lng_i = svgPoint[i].pPInputlongitude;
//         var lat_i = svgPoint[i].pPInputlatitude;
//
//         //  转换为平面坐标
//         svgPoint[i].x = svgPoint[i].pm_x = (lng_i - minLngNum ) * zoomNum + svgRectWidth + wuchaData;
//         svgPoint[i].y = svgPoint[i].pm_y = (maxLatNum - lat_i ) * zoomNum + wuchaData;
//
//         //  找出起始点
//         if(svgPoint[i].pPUpguid == "" || svgPoint[i].pPUpguid == null){
//             abs_x = svgPoint[i].pm_x;
//             abs_y = svgPoint[i].pm_y;
//         }
//     }
//
//     //  求下联点位的平面坐标
//     for (var i in svgPoint) {
//
//         //  当前点位经纬度
//         var lng_i = svgPoint[i].pPInputlongitude;
//         var lat_i = svgPoint[i].pPInputlatitude;
//
//         //  当前点位平面坐标
//         var pm_x_i = svgPoint[i].pm_x;
//         var pm_y_i = svgPoint[i].pm_y;
//
//         for (var k in svgPoint) {           //  上联信息
//
//             //  上联点位经纬度
//             var lng_k = svgPoint[k].pPInputlongitude;
//             var lat_k = svgPoint[k].pPInputlatitude;
//
//             //  上联点位平面坐标
//             var pm_x_k = svgPoint[k].pm_x;
//             var pm_y_k = svgPoint[k].pm_y;
//
//             //  下联点位
//             if (svgPoint[k].guid == svgPoint[i].pPUpguid ) {
//
//                 //  用经纬度坐标计算斜率
//                 var k0 = (lat_i-lat_k)/(lng_i-lng_k);
//                 //  x轴斜率
//                 var kx = 0 ;
//                 //  y轴不存在斜率，即Infinity
//                 //  当斜率k0出现 -Infinity 时，表示此点位组成的直线与y轴重合，且点位在y轴的负半轴
//                 //  当斜率k0出现 Infinity 时，表示此点位组成的直线与y轴重合，且点位在y轴的正半轴
//
//                 //  依附在x轴，【下户点、表箱距离用110，其余用100】
//                 if((k0<=1&&k0>=0) || (k0<0&&k0>=-1)){
//
//                     var dc = pm_x_i - pm_x_k;   //  上下联平面坐标的x坐标的差值
//                     // var dy = abs_x - pm_x_i;    //   起始点位与当前点位的x坐标的差值
//                     // var df = abs_y - pm_y_i;    //   起始点位与当前点位的y坐标的差值
//
//                     //  下户点、表箱用110
//                     if(svgPoint[i].pPName=="下户点" || svgPoint[i].pPName=="表箱"){
//
//                         if(svgPoint[i].isNode==false){          //  当前点位不是节点
//                             if(dc!=110){
//                                 if(svgPoint[k].upper == "y"){   //  上联点位依附在y轴
//
//                                     if(svgPoint[k].nextNum >= 0){
//                                         if(dc>0){
//                                             svgPoint[i].x = isNode_x + 110;
//                                             svgPoint[i].y = isNode_y + 110;
//                                         }else{
//                                             svgPoint[i].x = isNode_x - 110;
//                                             svgPoint[i].y = isNode_y + 110;
//                                         }
//                                     }
//
//                                     //  2019-9-3 10:15:51
//                                     // svgPoint[i].x = isNode_x;    // x轴坐标保持不变
//                                     // if(svgPoint[k].nextNum > 1){ // 上联点位是节点
//                                     //     svgPoint[i].y = isNode_y-i*110*0.1;
//                                     // }else{                        // 上联点位不是节点
//                                     //     svgPoint[i].y = svgPoint[k].y-110;
//                                     // }
//                                     // svgPoint[i].upper = "y"
//                                 }else if(svgPoint[i].upper = "x"){  //  上联点位依附在x轴
//                                     svgPoint[i].y = svgPoint[k].y;  //  y轴不变
//                                     if(svgPoint[k].nextNum > 1){     //  上联是节点
//                                         // svgPoint[i].x = isNode_x-i*100*0.1;
//                                         if(dc>0){       //  下联点位在上联点位的右边
//                                             svgPoint[i].x = svgPoint[k].x+110;
//                                         }else{          //  下联点位在上联点位的左边
//                                             svgPoint[i].x = svgPoint[k].x-110;
//                                         }
//                                     }else{                            //  上联不是节点
//                                         if(dc>0){
//                                             svgPoint[i].x = svgPoint[k].x+110;
//                                         }else{
//                                             svgPoint[i].x = svgPoint[k].x-110;
//                                         }
//                                         // svgPoint[i].x = svgPoint[k].x-100;
//                                     }
//                                     svgPoint[i].upper = "x"
//                                 }else{  //  其他情况
//                                     svgPoint[i].x = svgPoint[0].pm_x+i*110;
//                                     svgPoint[i].y = abs_y;
//                                 }
//                             }
//
//                         }else{              //  当前点位是节点
//
//                             if(dc!=100){
//                                 if(svgPoint[i].nextNum > 1){
//                                     svgPoint[i].upper = "x"
//                                     nux = svgPoint[i].nextNum;  //  节点数
//                                     if(dc>0){                   //   节点坐标
//                                         isNode_x = svgPoint[i].x = svgPoint[k].x+110;
//                                     }else{
//                                         isNode_x = svgPoint[i].x = svgPoint[k].x-110;
//                                     }
//                                     // isNode_x = svgPoint[i].x = svgPoint[0].pm_x+i*100;
//                                 }
//                                 // svgPoint[i].x = svgPoint[i].pm_x;                  //  x轴不变
//                                 // isNode_y = svgPoint[i].y = abs_y;        //  2019-8-26 16:30:13
//                                 isNode_y = svgPoint[i].y = svgPoint[k].y;
//                             }
//
//                         }
//
//                     }else{      //  其余点位用100
//                         if(svgPoint[i].isNode==false){  //  当前点位不是节点
//                             if(dc!=100){
//                                 if(svgPoint[k].upper == "y"){   //  上联依附在y轴
//                                     if(svgPoint[k].isNode){     //  上联是节点
//                                         svgPoint[i].y = svgPoint[k].y;
//                                         if(svgPoint[k].nextNum > 1){
//                                             if(dc>0){   //  下联点位在上联的右侧
//                                                 svgPoint[i].x = svgPoint[k].x+100;
//                                             }else{      //  下联点位在上联的左侧
//                                                 svgPoint[i].x = svgPoint[k].x-100;
//                                             }
//                                         }/*else{
//                                             if(dc>0){
//                                                 svgPoint[i].x = svgPoint[k].x+100;
//                                             }else{
//                                                 svgPoint[i].x = svgPoint[k].x-100;
//                                             }
//                                         }*/
//                                         svgPoint[i].upper = "x"
//                                     }else{                          //  上联点位不是节点
//                                         // svgPoint[i].x = isNode_x;       //  2019-9-2 16:58:46
//                                         // if(svgPoint[k].nextNum > 1){
//                                         //     svgPoint[i].y = isNode_y-i*100*0.1;
//                                         // }else{
//                                         //     svgPoint[i].y = svgPoint[k].y-100;  //  2019-9-2 16:58:46
//                                         // }
//                                         // svgPoint[i].upper = "y";        //  2019-9-2 16:58:46
//
//                                         if(dc>0){   //  下联点位在上联的右侧
//                                             svgPoint[i].x = svgPoint[k].x+100;
//                                         }else{      //  下联点位在上联的左侧
//                                             svgPoint[i].x = svgPoint[k].x-100;
//                                         }
//                                         svgPoint[i].y = svgPoint[k].y
//                                         svgPoint[i].upper = "x";
//                                     }
//                                 }else if(svgPoint[k].upper == "x"){ //  上联依附在x轴
//                                     svgPoint[i].y = svgPoint[k].y;
//                                     if(svgPoint[k].nextNum >= 0){     //  上联是节点
//                                         // svgPoint[i].x = isNode_x-i*100*0.1;
//                                         if(dc>0){   //  下联点位在上联的右侧
//                                             svgPoint[i].x = svgPoint[k].x+100;
//                                         }else{      //  下联点位在上联的右侧
//                                             svgPoint[i].x = svgPoint[k].x-100;
//                                         }
//                                     }/*else{                           // 上联不是节点
//                                         if(dc>0){
//                                             svgPoint[i].x = svgPoint[k].x+100;
//                                         }else{
//                                             svgPoint[i].x = svgPoint[k].x-100;
//                                         }
//                                         // svgPoint[i].x = svgPoint[k].x-100;
//                                     }*/
//                                     svgPoint[i].upper = "x"
//                                 }else{  //  其他情况
//                                     svgPoint[i].x = svgPoint[k].x + 100;
//                                     svgPoint[i].y = svgPoint[k].y;
//                                 }
//                             }
//                         }else{  //  当前点位是节点
//                             if(dc!=100){
//                                 if(svgPoint[i].nextNum > 1){        //  x轴需要再进行调试测试  2019-8-26 16:30:13
//                                     svgPoint[i].upper = "x"
//                                     nux = svgPoint[i].nextNum;      //  节点数
//                                     if(dc>0){       //  下联点位在上联的右侧
//                                         isNode_x = svgPoint[i].x = svgPoint[k].x+100;
//                                     }else{          //  下联点位在上联的左侧
//                                         isNode_x = svgPoint[i].x = svgPoint[k].x-100;
//                                     }
//                                 }
//                                 isNode_y = svgPoint[i].y = svgPoint[k].y;
//                             }
//                         }
//
//                     }
//
//                 }
//
//                 //  依附于y轴
//                 if((k0>1&&k0<57.29) || (k0<-1&&k0>-57.29)){
//
//                     var dc = pm_y_i - pm_y_k;
//                     // var dt = abs_x - pm_x_i;
//                     var dr = abs_y - pm_y_i;
//
//
//                     if(svgPoint[i].pPName=="下户点" || svgPoint[i].pPName=="表箱"){
//
//                         if(svgPoint[i].isNode==false){  //  当前点位不是节点
//                             if(dc!=110){
//
//                                 if(svgPoint[k].nextNum > 1){    //  上联点位是节点
//                                     if(nux<svgPoint[k].nextNum){//  当前节点数小于上联节点数
//                                         if(dc>0){   //  x轴向右发展
//                                             svgPoint[i].x = svgPoint[k].x+110;
//                                         }else{      //  x轴向左发展
//                                             svgPoint[i].x = svgPoint[k].x-110;
//                                         }
//                                         svgPoint[i].y = svgPoint[k].y;
//                                     }else{                      //  当前节点数大于等于上联节点数
//                                         svgPoint[i].x = isNode_x;
//                                         // if(dr>0){                       //  y轴向上发展
//                                         //     svgPoint[i].y = isNode_y-i*110*0.1;
//                                         // }else{                          //  y轴向下发展
//                                         //     svgPoint[i].y = svgPoint[k].y+110;
//                                         // }
//
//                                         if(dc>0){
//                                             svgPoint[i].y = svgPoint[k].y+110;
//                                         }else{
//                                             svgPoint[i].y = svgPoint[k].y-110;
//                                         }
//                                     }
//
//                                     nux--;
//                                 }else{      //  上联点位不是节点
//                                     /*if(isNode_x!=0){
//                                         svgPoint[i].x = isNode_x;
//                                         if(dr>0){
//                                             svgPoint[i].y = svgPoint[k].y-100;
//                                         }else{
//                                             svgPoint[i].y = svgPoint[k].y+100;
//                                         }
//                                     }else{*/
//                                         svgPoint[i].x = svgPoint[k].x;
//                                         if(dr>0){
//                                             svgPoint[i].y = svgPoint[k].y-110;
//                                         }else{
//                                             svgPoint[i].y = svgPoint[k].y+110;
//                                         }
//                                     // }
//
//                                 }
//                                 svgPoint[i].upper = "y";                         //  依附于y轴
//                             }
//
//                         }else{  //  当前点位是节点
//
//                             if(dc!=110){
//                                 svgPoint[i].upper = "y"
//                                 if(svgPoint[i].nextNum > 1){
//
//                                     nux = svgPoint[i].nextNum;  //  节点数
//
//                                     isNode_x = svgPoint[k].x;   //  节点坐标
//                                     isNode_y = svgPoint[k].y;
//
//                                     svgPoint[i].x = isNode_x;
//                                     svgPoint[i].y = isNode_y+110;
//                                 }/*else{
//                                     svgPoint[i].x = isNode_x;
//                                     svgPoint[i].y = svgPoint[i].pm_y+110;
//                                 }*/
//
//                             }
//
//                         }
//
//                     }else{  //  其他点位
//                         if(svgPoint[i].isNode==false){  //  当前点位不是节点
//                             if(dc!=100){
//
//                                 if(svgPoint[k].nextNum > 1){   //   上联点位是节点
//                                     if(nux<svgPoint[k].nextNum){    //  当前节点数小于上联点位节点数
//                                         // svgPoint[i].x = svgPoint[k].x-100;
//
//                                         //  2019-9-20 17:05:37 注释该段代码改为下段代码进行测试
//                                         // if(dc>0){   //  x轴向右发展
//                                         //     svgPoint[i].x = svgPoint[k].x+100;
//                                         // }else{      //  x轴向左发展
//                                         //     svgPoint[i].x = svgPoint[k].x-100;
//                                         // }
//                                         // svgPoint[i].y = svgPoint[k].y;
//
//
//                                         if(dc>0){   //
//                                             svgPoint[i].y = svgPoint[k].y+100;
//                                         }else{      //
//                                             svgPoint[i].y = svgPoint[k].y-100;
//                                         }
//                                         svgPoint[i].x = svgPoint[k].x;
//
//
//                                     }else{                          //  当前节点数大于等于上联点位节点数
//                                         svgPoint[i].x = isNode_x;
//                                         if(dr>0){                       //  y轴向上发展
//                                             // svgPoint[i].y = isNode_y-i*100*0.1;  //  2019-9-20 16:59:06 注释改为下一行
//                                             svgPoint[i].y = isNode_y+i*100*0.1;
//                                         }else{                          //  y轴向下发展
//                                             // svgPoint[i].y = svgPoint[k].y+100;   //  2019-9-20 16:59:06 注释改为下一行
//                                             svgPoint[i].y = svgPoint[k].y-100;
//                                         }
//                                     }
//
//                                     nux--;
//                                 }else{  //  上联点位不是节点
//                                     /*if(isNode_x!=0){
//                                         // svgPoint[i].x = isNode_x;
//                                         svgPoint[i].x = svgPoint[k].x
//                                         if(dc>0){
//                                             svgPoint[i].y = svgPoint[k].y+100;
//                                         }else{
//                                             svgPoint[i].y = svgPoint[k].y-100;
//                                         }
//                                     }else{*/
//                                         svgPoint[i].x = svgPoint[k].x;
//                                         if(dc>0){       //  y轴向上发展
//                                             svgPoint[i].y = svgPoint[k].y+100;
//                                         }else{          //  y轴向下发展
//                                             svgPoint[i].y = svgPoint[k].y-100;
//                                         }
//                                     // }
//
//                                 }
//                                 svgPoint[i].upper = "y";                         //  依附于y轴
//                             }
//                         }else{      //      当前点位是节点
//                             if(dc!=100){
//                                 svgPoint[i].upper = "y"
//                                 if(svgPoint[i].nextNum > 1){
//
//                                     nux = svgPoint[i].nextNum;  //  当前点位节点数
//
//                                     isNode_x = svgPoint[k].x;   //  节点坐标
//                                     isNode_y = svgPoint[k].y;
//
//                                     //  2019-9-20 17:23:57 注释该段代码，使用下段代码进行调试
//                                     // svgPoint[i].x = isNode_x;
//                                     // svgPoint[i].y = isNode_y+100;
//
//                                     svgPoint[i].x = isNode_x;
//                                     svgPoint[i].y = isNode_y-100;
//                                 }/*else{
//                                     svgPoint[i].x = isNode_x;                 //  x轴不变
//                                     svgPoint[i].y = svgPoint[i].pm_y+200;
//                                 }*/
//                             }
//                         }
//
//
//                     }
//
//                 }
//
//                 //  第三种情况：上联与下联组成的直线与y轴重合，不存在斜率时（即斜率∞）
//
//                 if(k0 == Infinity){   //  当前点位与上联点位组成的直线与y轴重合，且点位在y轴正半轴
//                     svgPoint[i].x = svgPoint[k].x;
//                     svgPoint[i].y = svgPoint[k].y-100;
//                 }else if(k0 == -Infinity){  //  当前点位与上联点位组成的直线与y轴重合，且点位在y轴负半轴
//                     svgPoint[i].x = svgPoint[k].x;
//                     svgPoint[i].y = svgPoint[k].y+100;
//                 }
//
//
//
//             }
//
//         }
//
//
//         //以下用于判断DXF宽度和高度用
//         if(maxSvgWidth < svgPoint[i].x+300){
//             maxSvgWidth = eval(svgPoint[i].x+300);
//         }
//         if(maxSvgHeight < svgPoint[i].y+320){
//             maxSvgHeight = eval(svgPoint[i].y+320);
//         }
//     }
//
//
//
//     /*for(var i = 0; i < svgPoint.length; i++){
//         if(svgPoint[i].pPWirenum > 0){
//             for (var j = 0; j < svgLaxian.length; j++) {
//                 if(svgPoint[i].guid == svgLaxian[j].pPGuid){
//
//
//                     // 原始拉线经纬度
//                     var lng_lx = svgLaxian[j].dLLongitude;
//                     var lat_lx = svgLaxian[j].dLLatitude;
//                     //  转换为平面坐标
//                     var lx_lng = svgLaxian[j].pm_x = (lng_lx - minLngNum ) * zoomNum + svgRectWidth + wuchaData;
//                     var lx_lat = svgLaxian[j].pm_y = (maxLatNum - lat_lx ) * zoomNum + wuchaData;
//
//                     //  移动后的拉线经纬度
//                     var lxX = 0;
//                     var lxY = 0;
//                     // 杆塔点位原始经纬度
//                     var gtLng = svgPoint[i].pm_x;
//                     var gtLat = svgPoint[i].pm_y;
//                     // 杆塔点位移动后的经纬度
//                     var gtX = svgPoint[i].x;
//                     var gtY = svgPoint[i].y;
//
//                     lxX = gtX - gtLng + lx_lng;
//                     lxY = gtY - gtLat + lx_lat;
//
//                     svgLaxian[j].x = (lxX-minLngNum)*zoomNum+svgRectWidth+wuchaData;
//                     svgLaxian[j].y = (maxLatNum-lxY)*zoomNum+wuchaData;
//                 }
//             }
//         }
//
//     }*/
//
//
//     /**
//      *  2.跨越点计算
//      */
//     var beforePoint , lastPoint;    //  上下联点位
//     for (var i = 0; i < svgPoint.length; i++) {     //  点位
//         //点位上联与交叉跨越上联点位
//         for (var j = 0; j < svgCross.length; j++) { //  跨越物
//             if (svgPoint[i].pPUpguid!=null && svgPoint[i].guid==svgCross[j].cCUpguid) {//上联点位
//                 beforePoint = svgPoint[i];
//             }
//             if (svgPoint[i].pPUpguid!=null && svgPoint[i].guid==svgCross[j].cCDownguid) {//下联点位
//                 lastPoint = svgPoint[i];
//             }
//
//             if(beforePoint != undefined && lastPoint != undefined){
//                 if(beforePoint.y == lastPoint.y){       //  上下联是水平排布
//                     svgCross[j].x = beforePoint.x + 30;
//                     svgCross[j].y = beforePoint.y;
//                 }else if(beforePoint.x == lastPoint.x){ //  上下联是竖直排布
//                     svgCross[j].x = beforePoint.x;
//                     svgCross[j].y = beforePoint.y + 30;
//                 }
//             }
//         }
//     }
//
//     // 单线框大小设置
//     if(maxSvgWidth>minSvgWidth){
//         svgWidth=maxSvgWidth;
//     }else{
//         svgWidth=minSvgWidth;
//     }
//
//     if(maxSvgHeight>minSvgHeight){
//         svgHeight=maxSvgHeight;
//     }else{
//         svgHeight=minSvgHeight;
//     }
//     svg.attr({width:svgWidth,height:svgHeight});
//
//     //指北标志
//     zhibei(svgWidth);   // ok
//     //描点
//     drawSvgPoint();     // ok
//     //画定位点之间的线
//     drawSvgLine();      // ok
//     //画拉线
//     drawPushLine();     // ok
//     //填写描述
//     drawDescribetion(); // ok
//     //画右下角标尺
//     drawSvgRemark();    // ok
// }


//  遵义横平竖直版--不参考经纬度，单独设置坐标，在上联的坐标上进行累计

// function load_svg_data(){
//
//     var minLngNum=minLng(svgPoint); //  最小经度
//     var maxLatNum=maxLat(svgPoint);  // 最大纬度
//     //经纬度转平面坐标系
//     var maxSvgWidth=0;
//     var maxSvgHeight=0;
//
//
//
//
//
//
//
//     // 点位经纬度
//     var n_x = 450,n_y=450;
//
//
//     for (var i in svgPoint) {
//         if (svgPoint[i].pPUpguid == "" || svgPoint[i].pPUpguid == null) {
//             svgPoint[i].x = svgPoint[i].abs_X = n_x;
//             svgPoint[i].y = svgPoint[i].abs_Y = n_y;
//         }
//     }
//
//
//
//     // for (var i = 0; i < svgPoint.length; i++) {
//     for (var i in svgPoint) {
//         // 当前点位经纬度
//         // var lng = svgPoint[i].pPInputlongitude;
//         // var lat = svgPoint[i].pPInputlatitude;
//
//         // 将原始经纬度转存,便于后期进行点位移动计算
//         svgPoint[i].RawX = svgPoint[i].pPInputlongitude;
//         svgPoint[i].RawY = svgPoint[i].pPInputlatitude;
//
//         //  i是当前点位
//         //  k是上联点位
//
//         for (var k in svgPoint) {
//
//             //  下联点位
//             if (svgPoint[k].guid == svgPoint[i].pPUpguid ) {
//
//                 //  上联点位的绝对坐标轴方向上的x、y坐标值
//                 var abs_x = svgPoint[k].x;
//                 var abs_y = svgPoint[k].y;
//
//                 //  由于是采用横向排布，则点位的y值不变，x值加上相应的等比距离
//                 if(svgPoint[i].nextNum <= 1){
//                     if(svgPoint[i].pPName=="表箱" || svgPoint[i].pPName=="下户点"){
//                         svgPoint[i].x = abs_x + 110 ; //   放大：110 ， 220 ，330
//                         svgPoint[i].y = abs_y;
//
//                         svgPoint[i].abs_X = abs_x + 110;
//                         svgPoint[i].abs_Y = abs_y;
//                     }else{
//                         svgPoint[i].x = abs_x + 100;
//                         svgPoint[i].y = abs_y;
//
//                         svgPoint[i].abs_X = abs_x + 100;
//                         svgPoint[i].abs_Y = abs_y;
//                     }
//                 }else if(svgPoint[i].nextNum == 2){
//                     //  由于是采用纵向排布，则点位的x值不变，y值加上相应的等比距离
//                     if(svgPoint[i].pPName=="表箱" || svgPoint[i].pPName=="下户点"){
//                         svgPoint[i].x = abs_x ;
//                         svgPoint[i].y = abs_y + 110;
//
//                         svgPoint[i].abs_X = abs_x ;
//                         svgPoint[i].abs_Y = abs_y + 110;
//                     }else{
//                         svgPoint[i].x = abs_x ;
//                         svgPoint[i].y = abs_y + 100;
//
//                         svgPoint[i].abs_X = abs_x ;
//                         svgPoint[i].abs_Y = abs_y + 100;
//                     }
//                 }
//
//
//             }
//
//         }
//
//
//         //以下用于判断DXF宽度和高度用
//         if(maxSvgWidth < svgPoint[i].x+300){
//             maxSvgWidth = eval(svgPoint[i].x+300);
//         }
//         if(maxSvgHeight < svgPoint[i].y+320){
//             maxSvgHeight = eval(svgPoint[i].y+320);
//         }
//
//     }
//
//
//     // 点位经纬度
//    /* var L = 0;
//     var XL = 0;
//     var XXL = 0;
//     var M = 0;
//     // for (var i = 0; i < svgPoint.length; i++) {
//     for (var i in svgPoint) {
//         // 当前点位经纬度
//         var lng = svgPoint[i].pPInputlongitude;
//         var lat = svgPoint[i].pPInputlatitude;
//
//         // 将原始经纬度转存,便于后期进行点位移动计算
//         svgPoint[i].RawX = svgPoint[i].pPInputlongitude;
//         svgPoint[i].RawY = svgPoint[i].pPInputlatitude;
//
//         for (var k in svgPoint) {
//             //  按比例缩小后的经纬度
//             var RawInfoX = 0;
//             var RawInfoY = 0;
//             M++;
//
//                 //  起始点位坐标不按比例缩小，即还是原点位坐标
//                 if (svgPoint[i].pPUpguid == "" || svgPoint[i].pPUpguid == null) {   //  up11当前点位的上联ID   later_pPUpguid下联点位的pPUpguid
//
//                     //  起点坐标固定(450，450)
//                     svgPoint[i].x = 450;
//                     svgPoint[i].y = 450;
//
//                     //  需要进行按比例缩小坐标
//                 }
//                 if ((svgPoint[k].guid == svgPoint[i].pPUpguid) &&
//                         (svgPoint[k].pPUpguid == "" || svgPoint[k].pPUpguid == null)) {
//
//
//                     svgPoint[k].x = 450;
//                     svgPoint[k].y = 450;
//
//                     // 点位原档距
//                     var abs_x1 = svgPoint[i].x;
//                     var abs_y1 = svgPoint[i].y;
//                     var abs_x2 = svgPoint[k].x;
//                     var abs_y2 = svgPoint[k].y;
//
//                     console.log("abs_x1=="+abs_x1+" " +
//                                  "abs_y1=="+abs_y1+" " +
//                                  "abs_x2=="+abs_x2+" " +
//                                  "abs_y2=="+abs_y2)
//
//                     console.log("svgPoint[i].pPCode11=="+svgPoint[i].pPCode)
//                     console.log("svgPoint[k].pPCode11=="+svgPoint[k].pPCode)
//
//
//                         if (svgPoint[i].pPName == "表箱" || svgPoint[i].pPName == "下户点") {
//                             svgPoint[i].x = 450+110*M;
//                             svgPoint[i].y = 450;
//                         } else {
//                             svgPoint[i].x = 450+100*M;
//                             svgPoint[i].y = 450;
//                         }
//
//
//
//
//                     //上联点位经纬度
//                     /!*var lng_1 = svgPoint[k].pPInputlongitude;
//                     var lat_1 = svgPoint[k].pPInputlatitude;
//
//                     // 点位原档距
//                     var Lqq = svgPoint[i].pPInputspan;
//                     //计算两点位的转换前的距离,两点间距离公式：|AB| = √(x1-x2)E2+(y1-y2)E2，Math.abs():绝对值；Math.sqrt():开平方；Math.pow(x,y):x的y次幂
//                     var AB = Math.abs(Math.sqrt(Math.pow((lng - lng_1), 2) + Math.pow((lat - lat_1), 2))) * 100000;
//                     var db = 0;
//                     var x3 = 0;
//                     var y3 = 0;
//                     if (Lqq != null) {
//                         db = isometricLineSegment(Lqq);//返回具体的等比线段表示长度
//                         L = Lqq + L;
//                         x3 = lng_1 + 20 * ( lng - lng_1 ) / 30;
//                         y3 = lat_1 + 20 * ( lat - lat_1 ) / 30;
//                         svgPoint[i].L = L;
//                     } else {
//                         if (svgPoint[i].pPName == "表箱") {
//                             db = isometricLineSegment(AB);//返回具体的等比线段表示长度
//                             XL = AB + XL;
//                             x3 = lng_1 + db * 2.2 * ( lng - lng_1 ) / XL;
//                             y3 = lat_1 + db * 2.2 * ( lat - lat_1 ) / XL;
//                             svgPoint[i].L = XL;
//                         } else {
//                             db = isometricLineSegment(AB);//返回具体的等比线段表示长度
//                             XL = AB + XL;
//                             x3 = lng_1 + db * 1.2 * ( lng - lng_1 ) / XL;
//                             y3 = lat_1 + db * 1.2 * ( lat - lat_1 ) / XL;
//                             svgPoint[i].L = XL;
//                         }
//                     }
//
//                     // 将计算后的点位新坐标重新赋值给点位，便于下个点位以此为计算
//                     svgPoint[i].pPInputlongitude = x3;
//                     svgPoint[i].pPInputlatitude = y3;
//
//                     RawInfoX = (x3 - minLngNum) * zoomNum + svgRectWidth + wuchaData;
//                     RawInfoY = (maxLatNum - y3) * zoomNum + wuchaData;
//
//                     RawInfoX = roundFun(RawInfoX, 8);
//                     RawInfoY = roundFun(RawInfoY, 8);
//
//                     svgPoint[i].x = RawInfoX;     // 计算画布的宽度和高度
//                     svgPoint[i].y = RawInfoY;*!/
//                 }else if (svgPoint[k].guid == svgPoint[i].pPUpguid){
//
//                     console.log("svgPoint[i].pPCode22=="+svgPoint[i].pPCode)
//                     console.log("svgPoint[k].pPCode22=="+svgPoint[k].pPCode)
//
//                     if (svgPoint[i].pPName == "表箱" || svgPoint[i].pPName == "下户点") {
//                         svgPoint[i].x = 450+110*M;
//                         svgPoint[i].y = 450;
//                     } else {
//                         svgPoint[i].x = 450+100*M;
//                         svgPoint[i].y = 450;
//                     }
//                 }
//
//         }
//
//
//         //以下用于判断DXF宽度和高度用
//         if(maxSvgWidth < svgPoint[i].x+300){
//             maxSvgWidth = eval(svgPoint[i].x+300);
//         }
//         if(maxSvgHeight < svgPoint[i].y+320){
//             maxSvgHeight = eval(svgPoint[i].y+320);
//         }
//
//     }*/
//
//
//
//     /**
//      *  2.拉线点计算
//      *
//      *  第一种方式：【以平行四边形来计算】
//      *      已知平行四边形的ABC三点，求第D点的坐标:
//      *          A(Xa,Ya) , B(Xb,Yb) , C(Xc,Yc) , D(Xd,Yd)
//      *
//      *      ==>
//      *          AB的向量差 = CD的向量差
//      *          B的向量 - A的向量 = C的向量 - D的向量
//      *          (Xb-Xa , Yb-Ya) = (Xc-Xd , Yc-Yd)
//      *          Xd = Xa-Xb+Xc ; Yd = Ya-Yb+Yc
//      *
//      *          A点为点位移动后的新坐标，B点为移动前的点位坐标，C点为移动前的拉线坐标，D点为移动后的拉线坐标
//      *
//      */
//
//
//     /*for(var i = 0; i < svgPoint.length; i++){
//         if(svgPoint[i].pPWirenum > 0){
//             for (var j = 0; j < svgLaxian.length; j++) {
//                 if(svgPoint[i].guid == svgLaxian[j].pPGuid){
//                     // 原始拉线经纬度
//                     var lng_lx = svgLaxian[j].dLLongitude;
//                     var lat_lx = svgLaxian[j].dLLatitude;
//                     //  移动后的拉线经纬度
//                     var lxX = 0;
//                     var lxY = 0;
//                     // 杆塔点位原始经纬度
//                     var gtLng = svgPoint[i].RawX;
//                     var gtLat = svgPoint[i].RawY;
//                     // 杆塔点位移动后的经纬度
//                     var gtX = svgPoint[i].pPInputlongitude;
//                     var gtY = svgPoint[i].pPInputlatitude;
//
//                     lxX = gtX - gtLng + lng_lx;
//                     lxY = gtY - gtLat + lat_lx;
//
//                     svgLaxian[j].x = (lxX-minLngNum)*zoomNum+svgRectWidth+wuchaData;
//                     svgLaxian[j].y = (maxLatNum-lxY)*zoomNum+wuchaData;
//                 }
//             }
//         }
//
//     }*/
//
//
//     /**
//      *  3.跨越点计算
//      */
//     var ef = 0;
//     for (var i = 0; i < svgPoint.length; i++) {
//         for (var k = 0; k < svgCross.length; k++) {
//
//             //  点位ID
//             var sguid = svgPoint[i].guid;
//             //
//             // // 交叉跨越经纬度
//             // var lng_k = svgCross[k].cCInputlongitude;
//             // var lat_k = svgCross[k].cCInputlatitude;
//             //
//             // //  交叉跨越上下联
//             var cCUpguid = svgCross[k].cCUpguid;
//             // var ccDownguid = svgCross[k].ccDownguid;
//
//             if (cCUpguid == sguid) {
//                 //  上联原始经纬度
//                 /*var gtLng = svgPoint[i].RawX;
//                 var gtLat = svgPoint[i].RawY;
//                 //  上联移动后的经纬度
//                 var lng_up = svgPoint[i].pPInputlongitude;
//                 var lat_up = svgPoint[i].pPInputlatitude;
//                 // 距离
//                 //计算跨越物点与上联点位的距离
//                 var MN = Math.abs(Math.sqrt(Math.pow((lng_up - lng_k), 2) + Math.pow((lat_up - lat_k), 2))) * 100000;
//                 ef = isometricLineSegment(MN);//返回具体的等比线段表示长度
//                 M = L;
//
//                 // 杆塔点位基础上进行计算
//                 var x6 = lng_up + ef * ( lng_k - lng_up ) / M;
//                 var y6 = lat_up + ef * ( lat_k - lat_up ) / M;
//
//                 // var x6 = lng_up + 20 * ( lng_k - lng_up ) / 30;
//                 // var y6 = lat_up + 20 * ( lat_k - lat_up ) / 30;
//
//                 svgCross[k].x = (x6 - minLngNum) * zoomNum + svgRectWidth + wuchaData;
//                 svgCross[k].y = (maxLatNum - y6) * zoomNum + wuchaData;*/
//
//
//                 /**
//                  *  以四边形来为做指导思想
//                  */
//                 // 原始跨越物经纬度
//                 var lng_k = svgCross[k].cCInputlongitude;
//                 var lat_k = svgCross[k].cCInputlatitude;
//                 //  移动后的跨越物经纬度
//                 var lxX = 0;
//                 var lxY = 0;
//                 // 杆塔点位原始经纬度
//                 var gtLng = svgPoint[i].RawX;
//                 var gtLat = svgPoint[i].RawY;
//                 // 杆塔点位移动后的经纬度
//                 var gtX = svgPoint[i].pPInputlongitude;
//                 var gtY = svgPoint[i].pPInputlatitude;
//
//                 lxX = gtX - gtLng + lng_k;
//                 lxY = gtY - gtLat + lat_k;
//
//                 svgCross[k].x = (lxX-minLngNum)*zoomNum+svgRectWidth+wuchaData;
//                 svgCross[k].y = (maxLatNum-lxY)*zoomNum+wuchaData;
//
//
//
//             }
//         }
//     }
//
//
//     // 单线框大小设置
//     if(maxSvgWidth>minSvgWidth){
//         svgWidth=maxSvgWidth;
//     }else{
//         svgWidth=minSvgWidth;
//     }
//
//     if(maxSvgHeight>minSvgHeight){
//         svgHeight=maxSvgHeight;
//     }else{
//         svgHeight=minSvgHeight;
//     }
//     svg.attr({width:svgWidth,height:svgHeight});
//
//     //指北标志
//     zhibei(svgWidth);   // ok
//     //描点
//     drawSvgPoint();     // ok
//     //画定位点之间的线
//     drawSvgLine();      // ok
//     //画拉线
//     drawPushLine();     // ok
//     //填写描述
//     drawDescribetion(); // ok
//     //画右下角标尺
//     drawSvgRemark();    // ok
// }

//描点-- 点位（svgPoint）
function drawSvgPoint(){
    //点位
    for(var i = 0; i < svgPoint.length; i++) {
        var pointObj = svgPoint[i];
        var x = pointObj.x; //经度转换
        var y = pointObj.y; //纬度转换
        // console.log("点位pointObj=="+JSON.stringify(pointObj))
        // if (svgPoint.length > 1) {
        if (pointObj.pPName == "搭火点") {//搭火点
            svg_catch_fire_point(x, y, false);
            svg.paper.text(x, y - 20, pointObj.pPCode);
        } else if (pointObj.pPName == "柱上变压器") {//柱上变压器
            svg_new_transformer(x, y, false);
            svg.paper.text(x, y - 10, pointObj.pPCode);
        } else if (pointObj.pPName == "箱式变电站") {//箱式变电站
            svg_new_pad_mounted(x, y, false);
            svg.paper.text(x, y - 10, pointObj.pPCode);
        } else if (pointObj.pPName == "杆塔") {//杆塔
            // svg_new_poles(x, y, false, pointObj.height);
            // svg.paper.text(x, y - 10, pointObj.pPCode);
            // svg.paper.text(x - 7, y + 5, pointObj.pPBar);//杆高

            if(pointObj.pPWorktype == "新增"){
                svg_new_poles(x, y, false, pointObj.pPBar);
                // svg.paper.text(x - 7, y + 5, pointObj.pPBar);//杆高
            }else if(pointObj.pPWorktype == "利旧"){
                svg_old_gt(x, y, false ,pointObj.pPBar);
            }
            svg.paper.text(x, y - 10, pointObj.pPCode+""+pointObj.pPType);

        } else if (pointObj.pPName == "下户点") {//下户点
            svg_next_door(x, y, false, "下户点", pointObj.pPHucount, "下户点");//下户名称和下户数量(pPHucount)
            svg.paper.text(x, y - 15, pointObj.pPCode);
        } else if (pointObj.pPName == "表箱") {//表箱
            svg_rect_center_text(x, y, pointObj.user_point, "表箱", false);
            svg.paper.text(x, y - 15, pointObj.pPCode);
        }else if(pointObj.pPName=="电缆井"){//电缆井
            svg_new_cable_well(x,y,false);
            svg.paper.text(x, y - 10, pointObj.pPCode);
        }/*else if(pointObj.pPName=="开关柜"){//开关柜
            svg_rect_center_text(x,y,"开关柜","开关柜",false);
            svg.paper.text(x, y - 15, pointObj.pPCode);
        }*/else if(pointObj.pPName=="墙支架"){
            svg_wall_support(x, y,false);
            svg.paper.text(x, y - 10, pointObj.pPCode);
        }
        // console.log(pointObj);
        /*else if(pointObj.pPName.equals("环网柜")){//环网柜
         svg_rect_center_text(x,y,"环网柜","环网柜",false);
         }else if(pointObj.pPName.equals("电缆分支箱")){//电缆分支箱
         svg_rect_center_text(x,y,"分支箱","电缆分支箱",false);
         }else if(pointObj.pPName.equals("开关站")){//开关站
         svg_rect_center_text(x,y,"开关站","开关站",false);
         }else if(pointObj.pPName.equals("配电室")){//配电室
         svg_rect_center_text(x,y,"配电室","配电室",false);
         }else if(pointObj.pPName.equals("沿墙电缆")){//沿墙电缆
         svg_new_cable_wall(x,y,false);
         }else if(pointObj.pPName.equals("通道电缆")){//通道电缆
         svg_new_passageway_wall(x,y,false);
         }else{//跨越物
         if(pointObj.next_exploration_id!=null&&pointObj.distance!=undefined){//跨越物没有下一级不画
         drawSvgCrossingThing(pointObj);
         }
         }*/
        // }
    }
    //  跨越物

    for(var i=0; i<svgCross.length;i++){
        // if(pointObj.next_exploration_id!=null&&pointObj.distance!=undefined){//跨越物没有下一级不画
        drawSvgCrossingThing(svgCross,svgPoint);
        // }
    }
}

/**
 * 画跨域物
 * @param pointObj--svgCross
 */
function drawSvgCrossingThing(svgCross,svgPoint){
    var beforePoint,lastPoint;//上联点和下联点对象
    var x;              //跨越物经纬度
    var y;
    var cross_type;     //跨越物类型
    var cross_span;     //跨越档距

    /*for(var i = 0; i < svgCross.length; i++){
     var tempPoint=svgCross[i];
     //上一个定位点
     if(pointObj.pPUpguid == tempPoint.cCUpguid){
     beforePoint=tempPoint;
     }
     //下一个定位点
     if(pointObj.guid == tempPoint.cCUpguid){
     lastPoint=tempPoint;
     }
     }*/


    // 点位与跨越物之间的关系
    for (var i = 0; i < svgPoint.length; i++) {     //  点位
        //点位上联与交叉跨越上联点位
        for (var j = 0; j < svgCross.length; j++) { //  跨越物
            if (svgPoint[i].pPUpguid!=null && svgPoint[i].guid==svgCross[j].cCUpguid) {//上联点位
                beforePoint = svgPoint[i];
            }
            if (svgPoint[i].pPUpguid!=null && svgPoint[i].guid==svgCross[j].cCDownguid) {//下联点位
                lastPoint = svgPoint[i];
            }
            // x = svgCross[j].x;               //跨越物经度
            // y = svgCross[j].y;                //跨越物纬度
            // cross_span = svgCross[j].cCSpan;                //跨越档距
            // cross_type =svgCross[j].cType;                  //跨越物类型
        }
    }

    //相似三角形比率
    for (var j = 0; j < svgCross.length; j++) { //  跨越物

        x = svgCross[j].x;               //跨越物经度
        y = svgCross[j].y;                //跨越物纬度
        cross_span = svgCross[j].cCSpan;                //跨越档距
        cross_type = svgCross[j].cType;                  //跨越物类型

        console.log("跨越物信息: svgCross="+JSON.stringify(svgCross))
        console.log("跨越物x: x="+x)
        console.log("跨越物y: y="+y)

        // if (lastPoint != undefined && lastPoint.pPInputspan != undefined && beforePoint.pPInputspan != undefined) {

            // var ratio=lastPoint.cCSpan/pointObj.pPInputspan;                 // 中心点
            // pointObj.x=(lastPoint.x-beforePoint.x)/ratio+beforePoint.x;
            // pointObj.y=(lastPoint.y-beforePoint.y)/ratio+beforePoint.y;
            // var x=pointObj.x;
            // var y=pointObj.y;
            if (lastPoint.x == beforePoint.x) {//两点位x坐标相等的时候
                var line1 = svg.paper.line(x - 70, y, x - 10, y).attr({
                    stroke: black_color,
                    fill: default_color,
                });
                var line2 = svg.paper.line(x + 10, y, x + 70, y).attr({
                    stroke: black_color,
                    fill: default_color,
                });
                svg.paper.polygon([x - 10, y, x - 30, y, x - 30, y - 5]).attr({
                    fill: black_color
                });
                svg.paper.polygon([x + 10, y, x + 30, y, x + 30, y - 5]).attr({
                    fill: black_color
                });
                svg.paper.text(x + 80, y + 5, getFeaturesName(cross_type)).attr({
                    style: "font-size:10pt", fill: default_color
                });
            } else if (lastPoint.y == beforePoint.y) {//两点位y坐标相等的时候
                var line1 = svg.paper.line(x, y - 70, x, y - 10).attr({
                    stroke: black_color,
                    fill: default_color,
                });
                var line2 = svg.paper.line(x, y + 10, x, y + 70).attr({
                    stroke: black_color,
                    fill: default_color,
                });
                svg.paper.polygon([x, y - 10, x, y - 30, x + 5, y - 30]).attr({
                    fill: black_color
                });
                svg.paper.polygon([x, y + 10, x, y + 30, x + 5, y + 30]).attr({
                    fill: black_color
                });
                svg.paper.text(x + 5, y + 80, getFeaturesName(cross_type)).attr({
                    style: "font-size:10pt", fill: default_color
                });
            } else { // 两点位x，y坐标均不相等的情况
                var k = (lastPoint.y - beforePoint.y) / (lastPoint.x - beforePoint.x);
                var b = lastPoint.y - k * lastPoint.x;
                drawMarker(k, b, x, y, getFeaturesName(cross_type));
            }
        // }
    }
}

/**
 *  跨越物类型
 *
 * @param pt_id
 * @returns {string}
 */
function getFeaturesName(pt_id){
    var fname="";
    switch(pt_id){
        case 101:fname="房屋";break;
        case 104:fname="通讯线路";break;
        case 102:fname="电力线路";break;
        case 100:fname="河流";break;
        case 103:fname="公路";break;
        case 105:fname="铁路";break;
        default :"";
    }
    return fname;
}

/**
 * 在一条直线上画出带箭头的跨越物
 * @param k
 * @param b
 * @param x
 * @param y
 * @param fname 跨越物名称
 */
function drawMarker(k,b,x,y,fname){
    var h1=10;
    var h2=30;
    var h3=50;
    var h4=5;
    var k2=-1/k;
    var b2=y-k2*x;
    var point1=getPointBykbAndDistance(k2,b2,h1,x,y);
    var point2=getPointBykbAndDistance(k2,b2,h2,x,y);
    var point3=getPointBykbAndDistance(k2,b2,h3,x,y);

    //明天任务 划线 跨越物名称筛选
    var line1=svg.paper.line(point1.x1,point1.y1, point3.x1,point3.y1).attr({
        stroke:black_color,
        fill:default_color,
    });
    var line2=svg.paper.line(point1.x2,point1.y2, point3.x2,point3.y2).attr({
        stroke:black_color,
        fill:default_color,
    });
    var b4=point2.y1-k*point2.x1;
    var point4=getPointBykbAndDistance(k,b4,h4,point2.x1,point2.y1);
    svg.paper.polygon([point1.x1,point1.y1,point2.x1,point2.y1,point4.x1,point4.y1]).attr({
        fill:black_color
    });
    var b5=point2.y2-k*point2.x2;
    var point5=getPointBykbAndDistance(k,b5,h4,point2.x2,point2.y2);
    svg.paper.polygon([point1.x2,point1.y2,point2.x2,point2.y2,point5.x1,point5.y1]).attr({
        fill:black_color
    });

    svg.paper.text(point3.x1, point3.y1, fname).attr({
        style:"font-size:10pt",fill:default_color
    });
}

/**
 * 画定位点之间的连线线
 */
function drawSvgLine(){
    for(var i = 0; i < svgPoint.length; i++){
        for(var j = 0; j < svgPoint.length; j++){
            if(svgPoint[i].guid==svgPoint[j].pPUpguid){
                var x1=svgPoint[i].x;   //  当前点位经纬度
                var y1=svgPoint[i].y;
                var x2=svgPoint[j].x;   //  上联点位经纬度
                var y2=svgPoint[j].y;
                if(svgPoint[j].pPVoltage==1){//10kv
                    svg_new_10kv_lines(x1,y1,x2,y2,false);
                }else if(svgPoint[j].pPVoltage==2){//0.38kv
                    svg_new_38_lines(x1,y1,x2,y2,false);
                }else if(svgPoint[j].pPVoltage==3){//0.22kv
                    svg_new_22_lines(x1,y1,x2,y2,false);
                }
                //档距
                drawTextByLine(svgPoint[i].x, svgPoint[i].y, svgPoint[j].x, svgPoint[j].y,Math.ceil(svgPoint[j].pPInputspan));
            }
        }
    }
}


//在线上方H处显示文字
function drawTextByLine(ax1,ay1,ax2,ay2,text){
    //在线上放H处显示文字
    var h=10;
    if(ax2!=ax1 && ay2!=ay1){
        var k=(-1)/((ay2-ay1)/(ax2-ax1));//算斜率
        var x1=(ax1+ax2)/2;
        var y1=(ay1+ay2)/2;
        var b=y1-k*x1;
        var ta=(h*h-x1*x1-(b-y1)*(b-y1))/(1+k*k);
        var tb=(k*b-k*y1-x1)/(1+k*k);
        var x2=Math.sqrt(ta+tb*tb)-tb;
        var y2=k*x2+b;
        svg.paper.text(x2, y2, text);
    }else{
        if(ax2==ax1){
            svg.paper.text(ax1+h, (ay2+ay1)/2, text);
        }else if(ay2==ay1){
            svg.paper.text((ax1+ax2)/2, ay1-h, text);
        }
    }

}


/**
 * 杆塔获取最小的经度
 * @param data
 * @returns {number}
 */
function minLng(data){
    var temp=180;
    for(var i = 0; i < data.length; i++){
        var lng=data[i].pPInputlongitude;

        if(lng!= null && temp > lng){
            temp=lng;
        }
    }
    return temp
}


/**
 * 杆塔获取最大纬度
 * @param data
 * @returns {number}
 */
function maxLat(data){
    var temp=0;
    for(var i = 0; i < data.length; i++){
        var lat=data[i].pPInputlatitude;

        if(lat!=null && temp < lat){
            temp=lat;
        }
    }
    return temp
}




/**
 * 拉线获取最小的经度
 * @param data
 * @returns {number}
 */
function minLxLng(data){
    var temp=180;
    for(var i = 0; i < data.length; i++){
        var lng=data[i].dLLongitude;

        if(lng!= null && temp > lng){
            temp=lng;
        }
    }
    return temp
}


/**
 * 拉线获取最大纬度
 * @param data
 * @returns {number}
 */
function maxLxLat(data){
    var temp=0;
    for(var i = 0; i < data.length; i++){
        var lat=data[i].dLLatitude;

        if(lat!=null && temp < lat){
            temp=lat;
        }
    }
    return temp
}



/**
 * 放大 【重新加载图例和点位信息】
 */
function svg_enlarge(){
    svg.clear();
    zoomNum=zoomNum*2;
    init_load(pGuid,pBName);
    //load_svg_data();
}
/**
 * 缩小 【重新加载图例和点位信息】
 */
function svg_narrow(){
    svg.clear();
    zoomNum=zoomNum/2;
    init_load(pGuid,pBName);
    //load_svg_data();
}

/**
 * 画拉线【按照点位关系】
 * @Time 2018-8-6 16:26:14 -- 点位信息和拉线信息
 */
// function drawPushLine(){
//
//     var minLxLngNum=minLxLng(svgLaxian); //  最小经度
//     var maxLxLatNum=maxLxLat(svgLaxian);  // 最大纬度
//
//     //  拉线点位的经纬度：dLLatitude、dLLongitude
//     //  杆塔点位的经纬度：pPInputlatitude、pPInputlongitude
//
//     //选出所有塔杆
//     var poleArr=new Array();
//     for(var i = 0; i < svgPoint.length; i++){
//         if(svgPoint[i].pPName=="杆塔" && svgPoint[i].pPWirenum > 0){//是塔杆且拉线数量大于0
//             poleArr.push(svgPoint[i]);
//         }
//     }
//
//     //2018-12-7 11:30:23
//     // 线路按照等比线段缩小后，拉线位置也需要改变
//     for(var i=0;i<poleArr.length;i++){
//         var x1 = poleArr[i].x;       //  杆塔经纬度
//         var y1 = poleArr[i].y;
//         var kmf = poleArr[i].pPInputspan;
//
//         for(var j=i;j<svgLaxian.length;j++){
//
//             // 拉线原始点位的经纬度
//             var lng_lx = svgLaxian[j].dLLongitude;
//             var lat_lx = svgLaxian[j].dLLatitude;
//
//             if(poleArr[i].pPWirenum >= 1){
//                 if(poleArr[i].guid == svgLaxian[j].pPGuid){
//                     var x2 = svgLaxian[j].x;      //  拉线经纬度
//                     var y2 = svgLaxian[j].y;
//                     drawLineTwoPoint(x1,y1,x2,y2);
//                 }
//             }
//         }
//     }
// }


/**
 *  画拉线【按照四象限法则】
 *  @Time 2019-8-28 10:25:02
 */
function drawPushLine() {
    //选出所有塔杆
    var poleArr = new Array();
    for (var i = 0; i < svgPoint.length; i++) {
        //  筛选出拉线不为0的杆塔
        if (svgPoint[i].pPName=="杆塔" && svgPoint[i].pPWirenum > 0) {
            poleArr.push(svgPoint[i]);
            //拉线数量
            if (svgPoint[i].pPWirenum > 1) {
                svg.paper.text(svgPoint[i].x - 15, svgPoint[i].y + 25, "【" + svgPoint[i].pPWirenum + "】").attr({
                    style: "font-size:10pt", fill: default_color
                });
            }

        }
    }
    //查出所有塔杆的上级和下级
    for (var i = 0; i < poleArr.length; i++) {
        var children = new Array();
        for (var j = 0; j < svgPoint.length; j++) {
            if (poleArr[i].guid == svgPoint[j].pPUpguid
                || poleArr[i].pPUpguid == svgPoint[j].guid) {
                children.push(svgPoint[j]);
            }
        }
        poleArr[i].children = children;
    }
    //甄别到底是一个塔杆还是2个还是2个以上，分别画拉线
    for (var i = 0; i < poleArr.length; i++) {
        var cNum = poleArr[i].children.length;
        if (cNum == 0) {    //有0个相关联的点位时，拉线位置垂直
            svg.paper.line(poleArr[i].x, poleArr[i].y, poleArr[i].x, poleArr[i].y + 20).attr({
                stroke: default_color,
                strokeWidth: 2
            });
            svg.paper.line(poleArr[i].x - 10, poleArr[i].y + 20, poleArr[i].x + 10, poleArr[i].y + 20).attr({
                stroke: default_color,
                strokeWidth: 2
            });
        } else if (cNum == 1) {     //有1个点位相关联时，拉线在延长线上
            var x1 = poleArr[i].x;
            var y1 = poleArr[i].y;
            var x2 = poleArr[i].children[0].x;
            var y2 = poleArr[i].children[0].y;

            drawLineTwoPoint(x1, y1, x2, y2);
        } else {    //当有1个以上的点位相关联时，拉线在最少的那个方向
            //点分组
            //四象限
            var xiangxian = [
                {"key": "++", "value": 0},
                {"key": "+-", "value": 0},
                {"key": "--", "value": 0},
                {"key": "-+", "value": 0}
            ];
            var x1 = poleArr[i].x;
            var y1 = poleArr[i].y;
            var children = poleArr[i].children;
            for (var j = 0; j < children.length; j++) {
                var x2 = children[j].x;
                var y2 = children[j].y;
                var tx = x2 - x1;
                var ty = y2 - y1;
                if (tx >= 0 && ty > 0) {//++
                    xiangxian[0].value++;
                } else if (tx > 0 && ty <= 0) {//+-
                    xiangxian[1].value++;
                } else if (tx <= 0 && ty < 0) {//--
                    xiangxian[2].value++;
                } else if (tx < 0 && ty >= 0) {//-+
                    xiangxian[3].value++;
                }
            }
            //得到最小象限
            var temp = xiangxian.length;
            var txx = 0;
            for (var j = 0; j < xiangxian.length; j++) {
                if (temp > xiangxian[j].value) {
                    temp = xiangxian[j].value;
                    txx = j;
                }
            }

            //++ -- 斜率为1
            var h = 20;//延长线距离
            if ("++" === xiangxian[txx].key) {
                var k = 1;
                var b = y1 - k * x1;
                var x2 = Math.sqrt(2) * h / 2 + x1;
                var y2 = Math.sqrt(2) * h / 2 + y1;
                drawLineNozero2(k, x1, y1, x2, y2);
            } else if ("--" == xiangxian[txx].key) {
                var k = -1;
                var b = y1 - k * x1;
                var x2 = x1 - Math.sqrt(2) * h / 2;
                var y2 = y1 - Math.sqrt(2) * h / 2;
                drawLineNozero2(k, x1, y1, x2, y2);
            } else if ("+-" === xiangxian[txx].key) {//+- -+ 斜率为-1
                var k = -1;
                var b = y1 + x1;
                var x2 = Math.sqrt(2) * h / 2 + x1;
                var y2 = y1 - Math.sqrt(2) * h / 2;
                drawLineNozero2(k, x1, y1, x2, y2);
            } else if ("-+" == xiangxian[txx].key) {
                console.log("txx="+txx)
                console.log("x1="+x1)
                console.log("h="+h)
                console.log("y1="+y1)
                var x2 = x1 - Math.sqrt(2) * h / 2;
                var y2 = Math.sqrt(2) * h / 2 + y1;
                console.log("x2="+x2)
                console.log("y2="+y2)
                drawLineNozero2(k, x1, y1, x2, y2);
            }
        }
    }
}


//画拉线,2个点的时候，包括平行X和Y的情况
function drawLineTwoPoint(x1,y1,x2,y2){
    if(x1!=x2 && y1!=y2){
        drawLineNozero(x1,y1,x2,y2);
    }else{
        drawLineZero(x1,y1,x2,y2);
    }
}
/**
 * 杆塔无下联时的拉线位置
 * @param x1
 * @param y1
 * @param x2
 * @param y2
 * @Time 2018-8-6 16:18:05
 */
//画拉线,2个点的时候,延长线斜率不为0的情况【开始画横竖拉线】
function drawLineNozero(x1,y1,x2,y2){
    var k=(y1-y2)/(x1-x2);
    var b=y1-k*x1;
    var h=5;//延长线距离
    //勾股定理+直线坐标公式
    //(x-x1)^2+(y-y1)^2=h^2
    //y=kx+b
    /* var ta=(h*h-x2*x2-(b-y2)*(b-y2))/(1+k*k);
     var tb=(k*b-k*y2-x2)/(1+k*k);
     // alertTip("ta="+ta+","+tb);
     var laxx=Math.sqrt(ta+tb*tb)-tb;
     if((laxx>x1 && laxx<x2)||(laxx<x1 && laxx>x2)){//如果正值在线段内，则取负值
     laxx=-Math.sqrt(ta+tb*tb)-tb;
     }
     var laxy=k*laxx+b;*/
    // alertTip("第一线="+x1+","+y1+","+x2+","+y2);
    //第一条线
    svg.paper.line(x1, y1, x2,y2).attr({
        stroke: default_color,
        strokeWidth: 2
    });
    //第二条线
    var laxk=-1/k;
    var laxb=y2-laxk*x2;
    var h2=10;//垂直线的一半
    //勾股定理+直线坐标公式
    //(x-x1)^2+(y-y1)^2=h^2
    //y=kx+b
    var ta2=(h2*h2-x2*x2-(laxb-y2)*(laxb-y2))/(1+laxk*laxk);
    var tb2=(laxk*laxb-laxk*y2-x2)/(1+laxk*laxk);
    //垂直线的第一个点根据公式计算出来
    var laxx1=Math.sqrt(ta2+tb2*tb2)-tb2;
    var laxy1=laxk*laxx1+laxb;
    var laxx2=x2+(x2-laxx1);
    var laxy2=laxk*laxx2+laxb;
    // alertTip("第二线="+laxx1+","+laxy1+","+laxx2+","+laxy2);
    svg.paper.line(laxx1, laxy1, laxx2,laxy2).attr({
        stroke: default_color,
        strokeWidth: 2
    });
}
/*function drawLineNozero(x1,y1,x2,y2){
 var k=(y1-y2)/(x1-x2);
 var b=y1-k*x1;
 var h=20;//延长线距离
 //勾股定理+直线坐标公式
 //(x-x1)^2+(y-y1)^2=h^2
 //y=kx+b
 var ta=(h*h-x1*x1-(b-y1)*(b-y1))/(1+k*k);
 var tb=(k*b-k*y1-x1)/(1+k*k);
 alertTip("ta="+ta+","+tb);
 var laxx=Math.sqrt(ta+tb*tb)-tb;
 if((laxx>x1 && laxx<x2)||(laxx<x1 && laxx>x2)){//如果正值在线段内，则取负值
 laxx=-Math.sqrt(ta+tb*tb)-tb;
 }
 var laxy=k*laxx+b;
 // alertTip("laxx="+x1+","+y1+","+laxx+","+laxy);
 //第一条线
 svg.paper.line(x1, y1, laxx,laxy).attr({
 stroke: default_color,
 strokeWidth: 2
 });
 //第二条线
 var laxk=-1/k;
 var laxb=laxy-laxk*laxx;
 var h2=10;//垂直线的一半
 //勾股定理+直线坐标公式
 //(x-x1)^2+(y-y1)^2=h^2
 //y=kx+b
 var ta2=(h2*h2-laxx*laxx-(laxb-laxy)*(laxb-laxy))/(1+laxk*laxk);
 var tb2=(laxk*laxb-laxk*laxy-laxx)/(1+laxk*laxk);
 //垂直线的第一个点根据公式计算出来
 var laxx1=Math.sqrt(ta2+tb2*tb2)-tb2;
 var laxy1=laxk*laxx1+laxb;
 var laxx2=laxx+(laxx-laxx1);
 var laxy2=laxk*laxx2+laxb;
 svg.paper.line(laxx1, laxy1, laxx2,laxy2).attr({
 stroke: default_color,
 strokeWidth: 2
 });
 }*/
//斜率为0的情况
function drawLineZero(x1,y1,x2,y2){
    if(x1==x2){

        if((y1-y2)<0){
            svg.paper.line(x1, y1, x1,y1-20).attr({
                stroke: default_color,
                strokeWidth: 2
            });

            svg.paper.line(x1-10, y1-20, x1+10,y1-20).attr({
                stroke: default_color,
                strokeWidth: 2
            });
        }else{
            svg.paper.line(x1, y1, x1,y1+20).attr({
                stroke: default_color,
                strokeWidth: 2
            });

            svg.paper.line(x1-10, y1+20, x1+10,y1+20).attr({
                stroke: default_color,
                strokeWidth: 2
            });
        }


    }else if(y1==y2){
        if((x1-x2)<0){
            svg.paper.line(x1, y1, x1-20,y1).attr({
                stroke: default_color,
                strokeWidth: 2
            });
            svg.paper.line(x1-20, y1-10, x1-20,y1+10).attr({
                stroke: default_color,
                strokeWidth: 2
            });
        }else{
            svg.paper.line(x1, y1, x1+20,y1).attr({
                stroke: default_color,
                strokeWidth: 2
            });
            svg.paper.line(x1+20, y1-10, x1+20,y1+10).attr({
                stroke: default_color,
                strokeWidth: 2
            });
        }
    }

}
//画拉线,两个点以上的时候,四象限画拉线用
//象限点数最少的45度画拉线
function drawLineNozero2(k0,x1,y1,x2,y2){
    var k=(y1-y2)/(x1-x2);
    var laxx=x2;
    var laxy=y2;
    //第一条线
    svg.paper.line(x1, y1, laxx,laxy).attr({
        stroke: default_color,
        strokeWidth: 2
    });
    //第二条线
    var laxk=-1/k;
    var laxb=laxy-laxk*laxx;
    var h2=10;//垂直线的一半
    //勾股定理+直线坐标公式
    //(x-x1)^2+(y-y1)^2=h^2
    //y=kx+b
    var ta2=(h2*h2-laxx*laxx-(laxb-laxy)*(laxb-laxy))/(1+laxk*laxk);
    var tb2=(laxk*laxb-laxk*laxy-laxx)/(1+laxk*laxk);
    //垂直线的第一个点根据公式计算出来
    var laxx1=Math.sqrt(ta2+tb2*tb2)-tb2;
    var laxy1=laxk*laxx1+laxb;
    var laxx2=laxx+(laxx-laxx1);
    var laxy2=laxk*laxx2+laxb;
    svg.paper.line(laxx1, laxy1, laxx2,laxy2).attr({
        stroke: default_color,
        strokeWidth: 2
    });
}
//是否为中文
function isChinese(temp)
{
    var reg=/[\u4E00-\u9FA5\uF900-\uFA2D]/;
    if (!reg.test(temp)){
        return false ;
    } else {
        return true ;
    }
}
//获取描述行数
function getHangNum(){
    var ziSize=350;//长度超过350换行
    var tempPx=0;
    var arr = svgSpec;
    var n=0;
    for(var i=0;i<arr.length;i++){
        var str = arr.substring(i,i+1);
        if(isChinese(str)){
            tempPx+=12;
        }else{
            tempPx+=8;
        }
        if(str=="。"){
            n++;tempPx=0;
        }else{
            if(tempPx > ziSize){
                n++;tempPx=0;
            }
        }

    }
    return n;
}

/**
 * 单线图描述
 */
function drawDescribetion(){
    var ziSize=400;//长度超过400换行
    // var arr = svgSpec.split("。");
    var arr = svgSpec;
    var n=getHangNum();
    var tempStr="";
    var tempPx = 0;
    for(var i=0;i<arr.length;i++){
        var str = arr.substring(i,i+1);
        tempStr+=str;
        if(isChinese(str)){
            tempPx+=12;
        }else{
            tempPx+=8;
        }
        if(str=="。"){
            svg.paper.text(30, svgHeight - 30*n-10, tempStr).attr({
                style:"font-size:10pt",fill:default_color
            });
            tempStr="";
            tempPx=0;
            n--;
        }else{
            if(tempPx > ziSize){
                svg.paper.text(30, svgHeight - 30*n-10, tempStr).attr({
                    style:"font-size:10pt",fill:default_color
                });
                tempStr="";
                tempPx=0;
                n--;
            }else if((i+1)==arr.length){
                svg.paper.text(30, svgHeight - 30*n-10, tempStr).attr({
                    style:"font-size:10pt",fill:default_color
                });
                tempStr="";
                tempPx=0;
                n--;
            }
        }
    }
}

//右下角矩形框长度和宽度
var rightBottomRectWidth=450;
var rightBottomRectHeight=200;
var fontSize="font-size:5pt";
/**
 * 右下角矩形框
 * @param svg
 */
function drawSvgRemark(){
    var textSizePx=12;
    //矢量图边框
    svg.paper.rect(0, 0, svgWidth, svgHeight, 0).attr({
        stroke:"rgb(0,0,0)",
        fill:"none",
        strokeWidth:"5",
    });

    //右下角矩形框
    var r2w=svgWidth-rightBottomRectWidth;
    var r2h=svgHeight-rightBottomRectHeight;
    svg.paper.rect(r2w, r2h, rightBottomRectWidth, rightBottomRectHeight, 0).attr({
        stroke:"rgb(0,0,0)",
        fill:"none",
        strokeWidth:"2",
    });
    var hanw=rightBottomRectWidth/12;
    var hanh=rightBottomRectHeight/5;
    //第一行
    svg.paper.line(r2w, r2h+hanh*1, svgWidth,r2h+hanh*1).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第一行 设计单位
    if(textsjdw != undefined && textsjdw!=''){
        var x1 = r2w+hanw*3-(textsjdw.length*textSizePx)/2;
        svg.paper.text(x1, r2h+hanh*0.6, textsjdw).attr({
            style:fontSize,fill:"rgb(0,0,0)"
        });
    }
    //第一行 第1根竖线
    svg.paper.line(r2w+hanw*6, r2h, r2w+hanw*6,r2h+hanh*1).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第一行 第2根竖线
    svg.paper.line(r2w+hanw*10, r2h, r2w+hanw*10,r2h+hanh*1).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });

    //第一行 汉字2
    var text2=projectName;
    var x2 = r2w+hanw*8-(text2.length*textSizePx)/2;
    svg.paper.text(x2, r2h+hanh*0.6, text2).attr({
        style:fontSize,fill:"rgb(0,0,0)"
    });

    //第一行 汉字3
    var text3=stageName;
    var x2 = r2w+hanw*11-(text3.length*textSizePx)/2;
    svg.paper.text(x2, r2h+hanh*0.6, text3).attr({
        style:fontSize,fill:"rgb(0,0,0)"
    });

    //第二行
    svg.paper.line(r2w, r2h+hanh*2, r2w+hanw*3,r2h+hanh*2).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    svg.paper.line(r2w+hanw*4, r2h+hanh*2, r2w+hanw*6,r2h+hanh*2).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第二行 第1根竖线
    svg.paper.line(r2w+hanw*1, r2h+hanh*1, r2w+hanw*1,r2h+hanh*2).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第二行 第2根竖线
    svg.paper.line(r2w+hanw*3, r2h+hanh*1, r2w+hanw*3,r2h+hanh*2).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //汉字
    var textpz="批准";
    var pzx = r2w+hanw*0.5-(textpz.length*textSizePx)/2;
    svg.paper.text(pzx, r2h+hanh*1.6, textpz).attr({
        style:fontSize,fill:"rgb(0,0,0)"
    });

    var textxh="校核";
    var xhx = r2w+hanw*3.5-(textxh.length*textSizePx)/2;
    svg.paper.text(xhx, r2h+hanh*2.1, textxh).attr({
        style:fontSize,fill:"rgb(0,0,0)"
    });
    //工程名称
    // var textgcmc="工程名称";
    textgcmc=textgcmc+" 示意图";
    if(textgcmc!=undefined && textgcmc!=''){
        var gcmcx = r2w+hanw*9-(textgcmc.length*textSizePx)/2;
        svg.paper.text(gcmcx, r2h+hanh*2.6, textgcmc).attr({
            style:fontSize,fill:"rgb(0,0,0)"
        });
    }
    //第二行 第3根竖线
    svg.paper.line(r2w+hanw*4, r2h+hanh*1, r2w+hanw*4,r2h+hanh*2).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    var textsh="审核";
    var shx = r2w+hanw*0.5-(textsh.length*textSizePx)/2;
    svg.paper.text(shx, r2h+hanh*3.1, textsh).attr({
        style:fontSize,fill:"rgb(0,0,0)"
    });
    //第二行 第4根竖线
    svg.paper.line(r2w+hanw*6, r2h+hanh*1, r2w+hanw*6,r2h+hanh*2).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第三行
    svg.paper.line(r2w+hanw*1, r2h+hanh*3, r2w+hanw*6,r2h+hanh*3).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第三行 第1根竖线
    svg.paper.line(r2w+hanw*1, r2h+hanh*2, r2w+hanw*1,r2h+hanh*3).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第三行 第2根竖线
    svg.paper.line(r2w+hanw*3, r2h+hanh*2, r2w+hanw*3,r2h+hanh*3).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第三行 第3根竖线
    svg.paper.line(r2w+hanw*4, r2h+hanh*2, r2w+hanw*4,r2h+hanh*3).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第三行 第4根竖线
    svg.paper.line(r2w+hanw*6, r2h+hanh*2, r2w+hanw*6,r2h+hanh*3).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第四行
    svg.paper.line(r2w, r2h+hanh*4, svgWidth,r2h+hanh*4).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第四行 第1根竖线
    svg.paper.line(r2w+hanw*1, r2h+hanh*3, r2w+hanw*1,r2h+hanh*4).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第四行 第2根竖线
    svg.paper.line(r2w+hanw*3, r2h+hanh*3, r2w+hanw*3,r2h+hanh*4).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //汉字
    var textsj="设计";
    var sjx = r2w+hanw*3.5-(textsj.length*textSizePx)/2;
    svg.paper.text(sjx, r2h+hanh*3.6, textsj).attr({
        style:fontSize,fill:"rgb(0,0,0)"
    });
    //第四行 第3根竖线
    svg.paper.line(r2w+hanw*4, r2h+hanh*3, r2w+hanw*4,r2h+hanh*4).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第四行 第4根竖线
    svg.paper.line(r2w+hanw*6, r2h+hanh*3, r2w+hanw*6,r2h+hanh*4).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第五行
    //第五行 第1根竖线
    svg.paper.line(r2w+hanw*1, r2h+hanh*4, r2w+hanw*1,r2h+hanh*5).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第五行 第2根竖线
    svg.paper.line(r2w+hanw*3, r2h+hanh*4, r2w+hanw*3,r2h+hanh*5).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第五行 第3根竖线
    svg.paper.line(r2w+hanw*4, r2h+hanh*4, r2w+hanw*4,r2h+hanh*5).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第五行 第4根竖线
    svg.paper.line(r2w+hanw*6, r2h+hanh*4, r2w+hanw*6,r2h+hanh*5).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第五行 第5根竖线
    svg.paper.line(r2w+hanw*7, r2h+hanh*4, r2w+hanw*7,r2h+hanh*5).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第五行 第6根竖线
    svg.paper.line(r2w+hanw*10, r2h+hanh*4, r2w+hanw*10,r2h+hanh*5).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第五行 第7根竖线
    svg.paper.line(r2w+hanw*11, r2h+hanh*4, r2w+hanw*11,r2h+hanh*5).attr({
        stroke: "rgb(0,0,0)",
        strokeWidth: 2
    });
    //第五行 汉字
    var textrh="日期";
    var brh = r2w+hanw*0.5-(textrh.length*textSizePx)/2;
    svg.paper.text(brh, r2h+hanh*4.6, textrh).attr({
        style:fontSize,fill:"rgb(0,0,0)"
    });

    var textbl="比列";
    var blx = r2w+hanw*3.5-(textbl.length*textSizePx)/2;
    svg.paper.text(blx, r2h+hanh*4.6, textbl).attr({
        style:fontSize,fill:"rgb(0,0,0)"
    });

    var textth="图号";
    var bth = r2w+hanw*6.5-(textth.length*textSizePx)/2;
    svg.paper.text(bth, r2h+hanh*4.6, textth).attr({
        style:fontSize,fill:"rgb(0,0,0)"
    });

    var textbc="版次";
    var bcx = r2w+hanw*10.5-(textbc.length*textSizePx)/2;
    svg.paper.text(bcx, r2h+hanh*4.6, textbc).attr({
        style:fontSize,fill:"rgb(0,0,0)"
    });


    /**
     * 将经纬度转换为平面坐标
     * @param lon
     * @param lat
     * @returns {{x: number, y: number}}
     * @Time 2018-8-6 09:38:17
     */
    // lon 经度，西经为负数
    // lat 纬度，南纬是负数

    /*var lat1=svgData[i].acableLat;
     var lng1=svgData[i].acableLng;

     function millerXY (lon1, lat1){
     var L = 6381372 * Math.PI * 2,     // 地球周长
     W = L, // 平面展开后，x轴等于周长
     H = L / 2, // y轴约等于周长一半
     mill = 2.3, // 米勒投影中的一个常数，范围大约在正负2.3之间
     x = lngLat.lng * Math.PI / 180, // 将经度从度数转换为弧度
     y = lngLat.lat * Math.PI / 180; // 将纬度从度数转换为弧度
     // 这里是米勒投影的转换
     y = 1.25 * Math.log( Math.tan( 0.25 * Math.PI + 0.4 * y ) );
     // 这里将弧度转为实际距离
     x = ( W / 2 ) + ( W / (2 * Math.PI) ) * x;
     y = ( H / 2 ) - ( H / ( 2 * mill ) ) * y;
     // alertTip("x="+x+";"+"y="+y);
     // 转换结果的单位是公里
     // 可以根据此结果，算出在某个尺寸的画布上，各个点的坐标
     return {
     x : x,
     y : y
     };
     }*/


}